开发问题汇总

1 上传aws内存溢出问题

文件上传aws时如果不设置文件内存长度，则 PutObjectRequest 会将文件全部加载到内存中来，

2 ZUUL网关响应头部不返回

https://www.jianshu.com/p/06da38e0c239

问题
默认的"Cookie",, "Set-Cookie","Authorization"会当做敏感信息头部不返回出去

解决

1. 可以通过修改配置来调整屏蔽的敏感信息头部，甚至可以不屏蔽敏感信息头部，全都返回，因为默认是有三个敏感信息头部的，所以需要手动设置来改变这个默认配置
2. 可以自己指定要屏蔽的response header，如果不想屏蔽，都要返回，那直接不写具体的内容即可，但是必须要增加这个配置

yml

zuul:
    sensitive-headers:

properties

zuul.sensitive-headers=

3 BigDecimal 丢失精度

/**
* 通过测试发现，当使用 double 或者 float 这些浮点数据类型时，会丢失精度，String、int 则不会
* 所以，在涉及到精度计算的过程中，我们尽量使用 String 类型来进行转换。
* <p>
* 88
* 8.8
* 8.800000000000000710542735760100185871124267578125
*/
@Test
public void test() {
    BigDecimal bigDecimal = new BigDecimal(88);
    System.out.println(bigDecimal);
    bigDecimal = new BigDecimal("8.8");
    System.out.println(bigDecimal);
    bigDecimal = new BigDecimal(8.8);
    System.out.println(bigDecimal);
}

1. 核心模块

Jackson 的核心模块由三部分组成

1. jackson-core，核心包, 提供基于"流模式"解析的相关 API，它包括 JsonPaser 和 JsonGenerator, Jackson内部实现正是通过高性能的流模式 API 的 JsonGenerator 和 JsonParser 来生成和解析 json。
2. jackson-annotations，注解包，提供标准注解功能。
3. jackson-databind ，数据绑定包， 提供基于"对象绑定" 解析的相关 API （ ObjectMapper ） 和"树模型" 解析的相关 API （JsonNode）；基于"对象绑定" 解析的 API 和"树模型"解析的 API 依赖基于"流模式"解析的 API。

2. 怎么用

2.1 引入依赖

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.5</version>
</dependency>

jackson-databind 依赖 jackson-core 和 jackson-annotations，当添加 jackson-databind 之后， jackson-core 和 jackson-annotations 也随之添加到 Java 项目工程中。在添加相关依赖包之后，就可以使用 Jackson。

2.2 对象绑定

Jackson 最常用的 API 就是基于"对象绑定" 的 ObjectMapper。

@Test
public void test() throws IOException {
    ObjectMapper mapper = new ObjectMapper();
    User user = new User();
    user.set..
    
    //序列化
    String jsonString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
    //反序列化
    user = mapper.readValue(jsonString, User.class);
}

2.2.1 writeValue

ObjectMapper 通过 writeValue 系列方法将 java 对象序列化为 json，并将 json 存储成不同的格式：String（writeValueAsString）、Byte Array（writeValueAsBytes）、Writer、File、OutStream、DataOutput。

2.2.2 readValue

ObjectMapper 通过 readValue 系列方法从不同的数据源： String、Byte Array、Reader、File、URL、InputStream 中反序列化为 java 对象。

在调用 writeValue 或调用 readValue 方法之前，往往需要设置 ObjectMapper 的相关配置信息。这些配置信息应用 java 对象的所有属性上。

示例如下

//在反序列化时忽略在 json 中存在但 Java 对象不存在的属性 
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES,false); 
//在序列化时日期格式默认为 yyyy-MM-dd'T'HH:mm:ss.SSSZ 
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS,false) 
//在序列化时忽略值为null的属性 
mapper.setSerializationInclusion(Include.NON_NULL); 
//忽略值为默认值的属性 
mapper.setDefaultPropertyInclusion(Include.NON_DEFAULT);

2.3 序列化

Jackson ObjectMapper提供了三种方法转换

writeValue()
writeValueAsString() 
writeValueAsBytes()

ObjectMapper objectMapper = new ObjectMapper();
Car car = new Car();
car.brand = "BMW";
car.doors = 4;

objectMapper.writeValue(new FileOutputStream("data/output-2.json"), car);
objectMapper.writeValue(new File("data/output-2.json"), car);
String json = objectMapper.writeValueAsString(car);
byte[] jsonBytes = objectMapper.writeValueAsBytes(car);

2.4 反序列化

从json字符串读取

ObjectMapper objectMapper = new ObjectMapper();
String carJson = "{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";
Car car = objectMapper.readValue(carJson, Car.class);

从json Reader读取

ObjectMapper objectMapper = new ObjectMapper();
String carJson = "{ \"brand\" : \"Mercedes\", \"doors\" : 4 }";
Reader reader = new StringReader(carJson);
Car car = objectMapper.readValue(reader, Car.class);

从json文件读取

ObjectMapper objectMapper = new ObjectMapper();
File file = new File("data/car.json");
Car car = objectMapper.readValue(file, Car.class);

从json网络文件地址读取

ObjectMapper objectMapper = new ObjectMapper();
URL url = new URL("file:data/car.json");
Car car = objectMapper.readValue(url, Car.class);

从流中读取

ObjectMapper objectMapper = new ObjectMapper();
InputStream input = new FileInputStream("data/car.json");
Car car = objectMapper.readValue(input, Car.class);

从json字节数组中读取

ObjectMapper objectMapper = new ObjectMapper();
String carJson = "{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";
byte[] bytes = carJson.getBytes("UTF-8");
Car car = objectMapper.readValue(bytes, Car.class);

2.4.1 反序列化不同类型

转换为数组

String jsonArray = "[{\"brand\":\"ford\"}, {\"brand\":\"Fiat\"}]";
ObjectMapper objectMapper = new ObjectMapper();
Car[] cars = objectMapper.readValue(jsonArray, Car[].class);

转换为集合

String jsonArray = "[{\"brand\":\"ford\"}, {\"brand\":\"Fiat\"}]";
ObjectMapper objectMapper = new ObjectMapper();
List<Car> cars = objectMapper.readValue(jsonArray, new TypeReference<List<Car>>(){});

转换为Map

String jsonObject = "{\"brand\":\"ford\", \"doors\":5}";
ObjectMapper objectMapper = new ObjectMapper();
Map<String, Object> jsonMap = objectMapper.readValue(jsonObject, new TypeReference<Map<String,Object>>(){});

2.5 时间类型格式化

Jackson 默认会将java.util.Date对象转换成long值,同时也支持将时间转换成格式化的字符串

SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
objectMapper.setDateFormat(dateFormat);

String json = objectMapper.writeValueAsString(对象);

2.6 JSON树模型

Jackson 也提供了树模型（tree model）来生成和解析 json。

若想修改或访问 json 部分属性，树模型是不错的选择。树模型由 JsonNode 节点组成

String carJson = "{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";
ObjectMapper objectMapper = new ObjectMapper();
try {
    JsonNode node = objectMapper.readValue(carJson, JsonNode.class);
    
    JsonNode brandNode = node.get("brand");
    String brand = brandNode.asText();
    System.out.println("brand = " + brand);

    JsonNode doorsNode = node.get("doors");
    int doors = doorsNode.asInt();
    System.out.println("doors = " + doors);

    JsonNode array = node.get("owners");
    JsonNode jsonNode = array.get(0);
    String john = jsonNode.asText();
    System.out.println("john  = " + john);

    JsonNode child = node.get("nestedObject");
    JsonNode childField = child.get("field");
    String field = childField.asText();
    System.out.println("field = " + field);
} catch (IOException e) {
    e.printStackTrace();
}

@Test
public void testJsonNode() throws JsonProcessingException {
    ObjectMapper mapper = new ObjectMapper();
    JsonNode node = mapper.readValue(JSON_STR, JsonNode.class);
    String firstName = node.get("firstName").asText();
    JsonNode phoneNumbers = node.get("phoneNumbers");
    Iterator<JsonNode> elements = phoneNumbers.elements();

    while (elements.hasNext()) {
        JsonNode next = elements.next();
        String type = next.get("type").asText();
        String number = next.get("number").asText();
        log.info("type:{}, number:{}", type, number);
    }
}

[main] INFO com.chris.hutool.json.JackSonTest - type:iPhone, number:0123-4567-8888
[main] INFO com.chris.hutool.json.JackSonTest - type:home, number:0123-4567-8910

2.7 JsonParser

JsonParser 提供很多方法来读取 json 信息， 如 isClosed(), nextToken(), getValueAsString()等。

若想单独创建 JsonParser，可以通过 JsonFactory() 的 createParser。

String carJson = "{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";
JsonFactory factory = new JsonFactory();
JsonParser  parser  = factory.createParser(carJson);

Car car = new Car();
while(!parser.isClosed()){
    JsonToken jsonToken = parser.nextToken();

    if(JsonToken.FIELD_NAME.equals(jsonToken)){
        String fieldName = parser.getCurrentName();
        System.out.println(fieldName);

        jsonToken = parser.nextToken();

        if("brand".equals(fieldName)){
            car.brand = parser.getValueAsString();
        } else if ("doors".equals(fieldName)){
            car.doors = parser.getValueAsInt();
        }
    }
}

System.out.println("car.brand = " + car.brand);
System.out.println("car.doors = " + car.doors);

也可以通过Reader, InputStream, URL, byte array 或 char array来创建JsonParser

2.8 JsonGenerator

JsonGenerator 有多种 write 方法以支持生成复杂的类型的 json，比如 writeArray，writeTree 等 。若想单独创建 JsonGenerator，可以通过 JsonFactory() 的 createGenerator。

JsonFactory factory = new JsonFactory();

JsonGenerator generator = factory.createGenerator(new File("data/output.json"), JsonEncoding.UTF8);

generator.writeStartObject();
generator.writeStringField("brand", "Mercedes");
generator.writeNumberField("doors", 5);
generator.writeEndObject();

generator.close();

3. 配置相关属性

SerializationFeature 序列化相关属性

DeserializationFeature 反序列化相关属性

MapperFeature

JsonParser.Feature（解析器特性）

JsonGenerator

JsonFactory

4. XML 实体互转

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.9.5</version>
</dependency>

/*
 * Java对象转xml
 */
@Test
public void testGenXml(){
    XmlMapper xmlMapper = new XmlMapper();
    Book book = new Book("Think in Java",100);
    try {
        String xmlStr =  xmlMapper.writeValueAsString(book);
        System.out.println(xmlStr);
    } catch (JsonProcessingException e) { 
        e.printStackTrace();
    }
}

/*
 * xml转Java对象
 */
@Test
public void testGenObjByXml(){
    XmlMapper xmlMapper = new XmlMapper();
    String xmlStr = "<Book><name>Think in Java</name><price>100</price></Book>"; 
    try {
        Book book = xmlMapper.readValue(xmlStr, Book.class);
        System.out.println(book);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

1 配置分页插件

配置分页插件:拦截对象

import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
public class MyBatisPlusConfig {

    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

2 默认分页

public IPage<VO> getxxxByPage(PageBean pageBean, VO queryVO) {
        Page<VO> page = new Page<>(pageBean.getCurrent(), pageBean.getSize());
        return tenantInfoMapper.getTenantByList(page, queryVO);
}

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;

IPage<VO> getxxx(Page<VO> page, @Param("vo") TenantVO 
queryVO);

3 自定义分页

private <B, T, P extends PageBean> List<B> buildPage(P p, Page<T> result, List<B> beans) {
        int current = Integer.parseInt(String.valueOf(p.getCurrent()));
        int size = Integer.parseInt(String.valueOf(p.getSize()));
        int fromIndex = (current - 1) * size;
        int toIndex = size * current;
        if (toIndex > beans.size()) {
            toIndex = beans.size();
        }

        List<B> pageBeans = beans.subList(fromIndex, toIndex);
        double pages = Math.ceil((double) beans.size() / (double) size);

        result.setPages((long) pages).setTotal(beans.size());

        return pageBeans;
}

1 Limit分页

limit ${startPos},${pageSize}

<select  parameterType="map" resultType="dayu">
    select * from user
    <if test="startPos!=null and pageSize!=null">
        limit ${startPos},${pageSize}
    </if>
</select>

@Test
public void selectUser() {
     SqlSession session = MybatisUtils.getSession();
     UserMapper mapper = session.getMapper(UserMapper.class);
       //这里塞值
      Map<String,Object> parms = new HashMap<>();
      parms.put("startPos","0");
      parms.put("pageSize","5");
     List<User> users = mapper.getUserInfo1(parms);
     for (User map: users){
         System.out.println(map);
      }
      session.close();
  }

总结：
limit 0,10;
0 代表从第0条数据开始
10 代表查10条数据
等到第二页的时候就是 limit 10,10;

2 RowBounds分页

RowBounds 帮我们省略了limit的内容，我们只需要在业务层关注分页即可！无须再传入指定数据！
这个属于逻辑分页，即实际上 sql查询的是所有的数据，在业务层进行了分页而已，比较占用内存，而且数据更新不及时，可能会有一定的滞后性！不推荐使用！

RowBounds对象有2个属性，offset和limit。

• offset: 起始行数
• limit：需要的数据行数
• 因此，取出来的数据就是：从第offset+1行开始，取limit行

@Test
public void selectUserRowBounds() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    // List<User> users = session.selectList("com.dy.mapper.UserMapper.getUserInfoRowBounds",null,new RowBounds(0, 5));
    List<User> users = mapper.getUserInfoRowBounds(new RowBounds(0,5));
    for (User map: users){
        System.out.println(map);
    }
    session.close();
}

List<User> getUserInfoRowBounds(RowBounds rowBounds);

<select  resultType="dayu">
   select * from user
</select>

3 Mybatis_PageHelper分页插件

官方GitHub地址：
https://github.com/pagehelper/Mybatis-PageHelper

<dependency>
   <groupId>com.github.pagehelper</groupId>
   <artifactId>pagehelper</artifactId>
   <version>5.1.7</version>
</dependency>

配置MyBatis核心配置文件

<plugins>
    <plugin interceptor="com.github.pagehelper.PageInterceptor" />
</plugins>

@Test
public void selectUserPageHelper() {
    SqlSession session = MybatisUtils.getSession();
    UserMapper mapper = session.getMapper(UserMapper.class);
    // 第二种，Mapper接口方式的调用，推荐这种使用方式。
    PageHelper.startPage(1, 3);
    List<User> list = mapper.getUserInfo();
    // 用PageInfo将包装起来
    PageInfo page = new PageInfo(list);
    for (User map: list){
        System.out.println(map);
    }
    System.out.println("page:---"+page);
    session.close();
 } 

//第一种，RowBounds方 sqlSe式的调用
List<User> list =ssion.selectList("x.y.selectIf", null, new RowBounds(0, 10));

//第二种，Mapper接口方式的调用，推荐这种使用方式。
PageHelper.startPage(1, 10);
List<User> list = userMapper.selectIf(1);

//第三种，Mapper接口方式的调用，推荐这种使用方式。
PageHelper.offsetPage(1, 10);
List<User> list = userMapper.selectIf(1);

//第四种，参数方法调用
//存在以下 Mapper 接口方法，你不需要在 xml 处理后两个参数
public interface CountryMapper {
    List<User> selectByPageNumSize(
            @Param("user") User user,
            @Param("pageNum") int pageNum, 
            @Param("pageSize") int pageSize);
}
//配置supportMethodsArguments=true
//在代码中直接调用：
List<User> list = userMapper.selectByPageNumSize(user, 1, 10);

//第五种，参数对象
//如果 pageNum 和 pageSize 存在于 User 对象中，只要参数有值，也会被分页
//有如下 User 对象
public class User {
    //其他fields
    //下面两个参数名和 params 配置的名字一致
    private Integer pageNum;
    private Integer pageSize;
}
//存在以下 Mapper 接口方法，你不需要在 xml 处理后两个参数
public interface CountryMapper {
    List<User> selectByPageNumSize(User user);
}
//当 user 中的 pageNum!= null && pageSize!= null 时，会自动分页
List<User> list = userMapper.selectByPageNumSize(user);

//第六种，ISelect 接口方式
//jdk6,7用法，创建接口
Page<User> page = PageHelper.startPage(1, 10).doSelectPage(new ISelect() {
    @Override
    public void doSelect() {
        userMapper.selectGroupBy();
    }
});
//jdk8 lambda用法
Page<User> page = PageHelper.startPage(1, 10).doSelectPage(()-> userMapper.selectGroupBy());

//也可以直接返回PageInfo，注意doSelectPageInfo方法和doSelectPage
pageInfo = PageHelper.startPage(1, 10).doSelectPageInfo(new ISelect() {
    @Override
    public void doSelect() {
        userMapper.selectGroupBy();
    }
});
//对应的lambda用法
pageInfo = PageHelper.startPage(1, 10).doSelectPageInfo(() -> userMapper.selectGroupBy());

//count查询，返回一个查询语句的count数
long total = PageHelper.count(new ISelect() {
    @Override
    public void doSelect() {
        userMapper.selectLike(user);
    }
});

//lambda
total = PageHelper.count(()->userMapper.selectLike(user));

拓展

//获取第1页，10条内容，默认查询总数count
PageHelper.startPage(1, 10);
List<User> list = userMapper.selectAll();
//用PageInfo对结果进行包装
PageInfo page = new PageInfo(list);
//测试PageInfo全部属性
//PageInfo包含了非常全面的分页属性
assertEquals(1, page.getPageNum());
assertEquals(10, page.getPageSize());
assertEquals(1, page.getStartRow());
assertEquals(10, page.getEndRow());
assertEquals(183, page.getTotal());
assertEquals(19, page.getPages());
assertEquals(1, page.getFirstPage());
assertEquals(8, page.getLastPage());
assertEquals(true, page.isFirstPage());
assertEquals(false, page.isLastPage());
assertEquals(false, page.isHasPreviousPage());

1.工具与框架的区别

1.1 工具

jdbc -> dbutils -> JdbcTemplate

1.2 框架

框架是一个整体解决方案,如何进行事务控制，如何实现查询缓存，字段映射

1.3 课程连接

https://my.oschina.net/jallenkwong/blog/4476789#h2_6

https://blog.csdn.net/u011863024/article/details/107854866

2. MyBatis

2.1 是什么

半自动化的ORM框架

以配置文件的形式手动编写SQL,非常灵活, 而将参数设置，预编译，执行，封装结果全部自动化

SQL和代码分开，实现业务与数据的解耦

2.1 去哪里下

2.1.1 源码

https://github.com/mybatis/mybatis-3

2.1.2 文档

https://mybatis.org/mybatis-3/

3. HelloWorld 案例

3.1 全局配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url"
                          value="jdbc:mysql://192.168.140.127:3306/chris?useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=CTT"/>
                <property name="username" value="root"/>
                <property name="password" value="65536"/>
            </dataSource>
        </environment>
    </environments>
    <!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
    <mappers>
        <mapper resource="./mapper/EmployeeMapper.xml"/>
        <mapper resource="./mapper/EmployeeServiceMapper.xml"/>
    </mappers>
</configuration>

3.2 SQL映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mybatis.employeemapper">
    <!--
    namespace:名称空间;通常指定为接口的全类名
    id：唯一标识
    resultType：返回值类型
    #{id}：从传递过来的参数中取出id值
    public Employee getEmpById(Integer id);
     -->
    <select id="getEmpById" resultType="com.mybatis.entity.Employee">
        select id, last_name lastName, email, gender
        from employee
        where id = #{id}
    </select>
</mapper>

3.3 业务类

package com.mybatis.entity;
import lombok.Data;

@Data
public class Employee {

    private int id;
    private String lastName;
    private String email;
    private String gender;
}

3.4 配置类

1. 根据全局配置文件得到SqlSessionFactory；

2. 使用SqlSessionFactory，获取到sqlSession对象使用他来执行增删改查 一个sqlSession就是代表和数据库的一次会话，用完关闭

3. 使用sql的唯一标识来告诉MyBatis执行哪个sql。sql都是保存在sql映射文件中的。

private SqlSessionFactory getSqlSessionFactory() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        return new SqlSessionFactoryBuilder().build(inputStream);
}
 
@Test
public void test() throws IOException {
    // 获取sqlSession实例，能直接执行已经映射的sql语句
    // sql的唯一标识：statement Unique identifier matching the statement to use.
    // 执行sql要用的参数：parameter A parameter object to pass to the statement.

    SqlSessionFactory sqlSessionFactory;
    SqlSession openSession = null;
    try {
        sqlSessionFactory = getSqlSessionFactory();
        openSession = sqlSessionFactory.openSession();
        // 加上namesapce com.mybatis.employeemapper 可以防止调用同名方法时冲突
        Employee employee = openSession.selectOne("com.mybatis.employeemapper.getEmpById", 1);
        System.out.println(employee);
    } catch (IOException e) {
        e.printStackTrace();
        throw e;
    } finally {
        if (null != openSession) {
            openSession.close();
        }
    }
}

3.5 接口式编程

3.5.1 创建接口

package com.mybatis.dao.mapper;

import com.mybatis.entity.Employee;

public interface EmployeeMapper {
    Employee getEmployeeById(int id);
}

3.5.2 SQL映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!-- mybatis 支持namespace与接口名称绑定 -->
<mapper namespace="com.mybatis.dao.mapper.EmployeeMapper">
    <select id="getEmployeeById" resultType="com.mybatis.entity.Employee">
        select id, last_name lastName, email, gender
        from employee
        where id = #{id}
    </select>
</mapper>

3.5.3 测试代码

/**
 * 通过接口绑定来查询数据
 *
 * @throws IOException
 */
@Test
public void test02() throws IOException {
    SqlSessionFactory sqlSessionFactory;
    SqlSession openSession = null;
    try {
        sqlSessionFactory = getSqlSessionFactory();
        openSession = sqlSessionFactory.openSession();
        EmployeeMapper employeeMapper = openSession.getMapper(EmployeeMapper.class);
        Employee employee = employeeMapper.getEmployeeById(1);
        System.out.println(employee.getClass());
        System.out.println(employee);
    } catch (IOException e) {
        e.printStackTrace();
        throw e;
    } finally {
        if (null != openSession) {
            openSession.close();
        }
    }
}

结果

class com.sun.proxy.$Proxy6
Employee(id=1, lastName=chris, email=sss@1734.com, gender=m)

4.全局配置文件

4.1 标签

全局配置中标签需要按照此顺序编写

properties
settings
typeAliases
typeHandlers
objectFactory
objectWrapperFactory
reflectorFactory
plugins
environments
databaseIdProvider
mappers

4.1.1 properties

mybatis使用properties标签来引入外部properties配置文件的内容

resource 指向类路径下的资源文件

url 引用网络路径或本地磁盘上的资源文件

1. 建properties文件

   mybatis-chris-helloworld-2/src/main/:/dbconfig

   jdbc.driver=com.mysql.cj.jdbc.Driver
   jdbc.url=jdbc:mysql://192.168.140.127:3306/chris?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=CTT
   jdbc.username=root
   jdbc.password=65536
   

2. 改全局配置文件

   mybatis-chris-helloworld-2/src/main/:/mybatis-config.xml

   <configuration>
       <properties resource="dbconfig.properties"/>
   
       <environments default="development">
           <environment id="development">
               <transactionManager type="JDBC"/>
               <dataSource type="POOLED">
                   <property name="driver" value="${jdbc.driver}"/>
                   <property name="url" value="${jdbc.url}"/>
                   <property name="username" value="${jdbc.username}"/>
                   <property name="password" value="${jdbc.password}"/>
               </dataSource>
           </environment>
       </environments>
       <!-- 将我们写好的sql映射文件（EmployeeMapper.xml）一定要注册到全局配置文件（mybatis-config.xml）中 -->
       <mappers>
           <mapper resource="./mapper/EmployeeMapper.xml"/>
           <mapper resource="./mapper/EmployeeServiceMapper.xml"/>
       </mappers>
   </configuration>
   

4.1.2 settings

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
    
  <!--开启表中下划线字段A_COLUMN转JavaBean驼峰字段aColumn-->
  <setting name="mapUnderscoreToCamelCase" value="false"/>
    
  <setting name="localCacheScope" value="SESSION"/>
    
  <!--指定字段值为null时的JDBC type，默认为OTHER-->
  <setting name="jdbcTypeForNull" value="OTHER"/>
  
    <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

4.1.3 typeAliases

别名处理器，可以为Java类型起别名, 且别名不区分大小写

1. 在全局配置中添加

   <typeAliases>
   	<!--
   	type:为Java类型的全类名，没有设置别名的情况下默认别名为类名全小写, com.mybatis.entity.Employee的默认别名为employee
   	alias: 为Java类型指定别名
   	-->
       <typeAlias type="com.mybatis.entity.Employee" alias="emp"/>
   
       <!--
       为当前包以及子包里面的类起一个默认的别名
       批量起别名时如果别名重复，可以使用@Alias("employeeAlias")为Java类指定新的别名
       -->
       <package name="com.mybatis.entity"/>
   </typeAliases>
   

2. 业务类

   package com.mybatis.entity;
   import lombok.Data;
   import org.apache.ibatis.type.Alias;
   
   @Data
   @Alias("employeeAlias")
   public class Employee {
       private int id;
       private String lastName;
       private String email;
       private String gender;
   }
   

3. 在SQL映射文件中指定

   <!-- 测试默认别名, 别名不区分大小写 Employee和employ都可以-->
   <select id="testDefaultAlias" resultType="Employee">
       select *
       from employee
       where id = #{id}
   </select>
   
   <!-- 测试指定别名emp, 别名不区分大小写 Emp和emp都可以 -->
   <select id="testSpecifiedAlias" resultType="Emp">
       select *
       from employee
       where id = #{id}
   </select>
   
   <!-- 在类上使用@Alias("employeeAlias")指定别名 -->
   <select id="testSpecifiedAlias" resultType="employeeAlias">
       select *
       from employee
       where id = #{id}
   </select>
   

4.1.4 typeHandlers

处理Java类型与数据库表字段类型相互转换

NOTE Since version 3.4.5, MyBatis supports JSR-310 (Date and Time API) by default.

private List<Object> templateStickerImg;

<result column="quality_accessories" property="qualityAccessories" typeHandler="com.baomidou.mybatisplus.extension.handlers.JacksonTypeHandler"/>

4.1.5 plug-ins

MyBatis allows you to intercept calls to at certain points within the execution of a mapped statement. By default, MyBatis allows plug-ins to intercept method calls of:

• Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
• ParameterHandler (getParameterObject, setParameters)
• ResultSetHandler (handleResultSets, handleOutputParameters)
• StatementHandler (prepare, parameterize, batch, update, query)

4.1.6 environments

可以用来配置多种环境

org.apache.ibatis.session.Configuration

this.typeAliasRegistry.registerAlias("JDBC", JdbcTransactionFactory.class);
this.typeAliasRegistry.registerAlias("MANAGED", ManagedTransactionFactory.class);
this.typeAliasRegistry.registerAlias("JNDI", JndiDataSourceFactory.class);
this.typeAliasRegistry.registerAlias("POOLED", PooledDataSourceFactory.class);
this.typeAliasRegistry.registerAlias("UNPOOLED", UnpooledDataSourceFactory.class);

<environment id="development">
            <!-- 有两种类型的事务控制 JDBC|MANAGED , org.apache.ibatis.session.Configuration-->
            <transactionManager type="JDBC"/>
            <!--
           数据源
           type:
               UNPOOLED:不使用连接池的数据源
               POOLED:使用边境池的数据源
               JNDI:
               自定义数据源:实现DataSourceFactory接口-->
            <dataSource type="POOLED">
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            </dataSource>
</environment>

4.1.7 databaseIdProvider

用来白支持多数据库厂商，得到不同数据库厂商的标识，mybatis跟据不同厂商的标识执行不同的SQL

DB_VENDOR - 会通过 DatabaseMetaData#getDatabaseProductName() 返回的字符串进行设置。由于通常情况下这个字符串都非常长而且相同产品的不同版本会返回不同的值，所以最好通过设置属性别名来使其变短

this.typeAliasRegistry.registerAlias("DB_VENDOR", VendorDatabaseIdProvider.class);

1. mybatis-chris-helloworld-2/src/main/:/mybatis-config.xml

   <!--
   用来支持多数据库
   type: DB_VENDOR, 厂商标识由驱动自带
   -->
   <databaseIdProvider type="DB_VENDOR">
       <!--
       为不同的数据库厂商标识起别名
       name:数据库厂商标识
       value:别名
       -->
       <property name="MYSQL" value="mysql"/>
       <property name="Oracle" value="oralce"/>
       <property name="SQL Server" value="sqlserver"/>
   </databaseIdProvider>
   

2. mybatis-chris-helloworld-2/src/main/:/mapper/Employee2Mapper.xml

   <!-- 在指定的mysql上数据库上执行，databaseId为databaseIdProvider的别名  -->
   <select id="testSpecifiedAlias" resultType="employeeAlias" databaseId="mysql">
       select *
       from employee
       where id = #{id}
   </select>
   
   <!-- 在指定的oralce上数据库上执行，databaseId为databaseIdProvider的别名  -->
   <select id="testSpecifiedAlias" resultType="employeeAlias" databaseId="oralce">
       select *
       from employees
       where id = #{id}
   </select>
   

4.1.8 mappers

将写好的sql映射文件（EmployeeMapper.xml）注册到全局配置文件（mybatis-config.xml）中

1. mapper 单个注册

   resource: 注册类路径下的资源文件

   <mappers>
   <mapper resource="./mapper/EmployeeMapper.xml"/>
   <mapper resource="./mapper/Employee2Mapper.xml"/>
   </mappers>
   

   url: 注册网络路径或本地磁盘上的资源文件

   <mappers>
   <mapper url="file:///var/mappers/AuthorMapper.xml"/>
   <mapper url="file:///var/mappers/BlogMapper.xml"/>
   </mappers>
   

   class: 注册接口

   1. 将SQL映射文件与接口入在同一类路径下，并且与接口名称一致

      <mappers>
          <mapper resource="com.mybatis.dao.mapper.EmployeeMapper"/>
      </mappers>
      

   2. 不用SQL映射文件，基于注解的SQL映射， 不建议，因为会使代码和SQL耦合，使业务和数据逻辑混乱

      package com.mybatis.dao.mapper;
      import com.mybatis.entity.Employee;
      import org.apache.ibatis.annotations.Select;
      
      public interface EmployeeAnnotationMapper {
          @Select("select *  from employee  where id = #{id}")
          Employee getEmployeeById(int id);
      }
      

      <mappers>
          <mapper class="com.mybatis.dao.mapper.EmployeeAnnotationMapper"/>
      </mappers>
      

2. 批量注册

   <mappers>
      <!-- 批量注册
      name:接口所在的包路径
      适用于通过注解实现SQL映射的接口，对于通过配置文件实现的SQL映射，需要将XML文件与接口放在一起，否则无法批量注册
      -->
       <package name="com.mybatis.dao.mapper"/>
   </mappers>
   

5. 映射文件

5.1 标签

cache – Configuration of the cache for a given namespace.
cache-ref – Reference to a cache configuration from another namespace.
resultMap – The most complicated and powerful element that describes how to load your objects from the database result sets.
parameterMap – Deprecated! Old-school way to map parameters. Inline parameters are preferred and this element may be removed in the future. Not documented here.
sql – A reusable chunk of SQL that can be referenced by other statements.
insert – A mapped INSERT statement.
update – A mapped UPDATE statement.
delete – A mapped DELETE statement.
select – A mapped SELECT statement.

5.2 增删改查

mybatis 自动封装了增删改的返回结果
int 和 long 表示影响的行数
boolean 表示是否执行成功
void表示什么都不返回

1. 业务接口

   package com.mybatis.dao.mapper;
   import com.mybatis.entity.Employee;
   
   public interface EmployeeMapper {
       Employee getEmployeeById(int id);
       int addEmployee(Employee employee);
       int deleteEmployeeById(int id);
       int updateEmployee(Employee employee);
   }
   

2. SQL映射文件

   <mapper namespace="com.mybatis.dao.mapper.EmployeeMapper">
       <select id="getEmployeeById" resultType="com.mybatis.entity.Employee">
           select *
           from employee
           where id = #{id}
       </select>
       <!--parameterType: 可以省略-->
       <insert id="addEmployee" parameterType="com.mybatis.entity.Employee">
           insert into employee (last_name, email, gender)
           values (#{lastName}, #{email}, #{gender})
       </insert>
   
       <update id="updateEmployee">
           update employee t
           set t.last_name=#{lastName},
               t.email=#{email},
               gender=#{gender}
           where t.id = #{id}
       </update>
   
       <delete id="deleteEmployeeById">
           delete
           from employee
           where id = #{id}
       </delete>x
   </mapper>
   

5.3 获取MySql自增主键

1. 修改SQL映射文件

   <!--
   parameterType: 可以省略
   useGeneratedKeys: 设置为true，使用自增主键策略获取主键
   keyProperty: 指定对应的主键属性，即当获取主键后将值封装给JavaBean中的哪个属性
   -->
   <insert id="addEmployee" parameterType="com.mybatis.entity.Employee" useGeneratedKeys="true" keyProperty="id">
       insert into employee (last_name, email, gender)
       values (#{lastName}, #{email}, #{gender})
   </insert>
   

2. 测试代码

   @Test
   public void addEmployee() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession = sqlSessionFactory.openSession();
           EmployeeMapper employeeMapper = openSession.getMapper(EmployeeMapper.class);
           Employee employee = new Employee("Cano", "Cano@gmail.com", "F");
           employeeMapper.addEmployee(employee);
           System.out.println("add user id:" + employee.getId());
           openSession.commit();
   
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           if (null != openSession) {
               openSession.close();
           }
       }
   }
   

5.4 获取Oracle Sequence值

1. 改SQL映射文件

   <!--
   使用Oracle Sequence添加员工记录前获取ID
   -->
   <insert parameterType="com.mybatis.entity.Employee" database>
       <!--
       keyProperty: 指定对应的主键属性，即当获取主键后将值封装给JavaBean中的哪个属性
       order: BEFORE 当前SQL在插入SQL之前运行
              AFTER  当前SQL在插入SQL之后运行
       resultType: 查出的数据返回类型
       -->
       <selectKey keyProperty="id" order="BEFORE" resultType="Integer">
           select EMPLOYEES_SEQ.nextval from dual
       </selectKey>
       <!-- 插入时的主键是从序列中拿到 -->
       insert into employee (id, last_name, email, gender)
       values (#{id}, #{lastName}, #{email}, #{gender})
   </insert>
   
   <!--
   使用Oracle Sequence添加员工记录后获取ID
    -->
   <insert parameterType="com.mybatis.entity.Employee" database>
       <!--
       keyProperty: 指定对应的主键属性，即当获取主键后将值封装给JavaBean中的哪个属性
       order: BEFORE 当前SQL在插入SQL之前运行
              AFTER  当前SQL在插入SQL之后运行
       resultType: 查出的数据返回类型
       -->
       <selectKey keyProperty="id" order="AFTER" resultType="Integer">
           select EMPLOYEES_SEQ.currval from dual
       </selectKey>
       <!-- 插入时的主键是从序列中拿到 -->
       insert into employee (id, last_name, email, gender)
       values (EMPLOYEES_SEQ.nextval, #{lastName}, #{email}, #{gender})
   </insert>
   

5.4 参数处理

5.4.1 单个参数

#{参数名} 

单个参数Mybatis不作特殊处理

5.4.2 多个参数

1. Mybatis会将参数封装成Map，key从 param1~paramN

   #{参数名} 是从Map中取到指定key的值
   第一个参数： #{param1} 
   第二个参数： #{param2} 
   

2. 命名参数

   需要在接口中的方法参数上使用@Param("lastName")
   参数会被封装成Map，key是@Param注解中指定的值
   取值#{lastName}
   

   Employee getEmployeeByIdAndName2(@Param("id") int id, @Param("lastName") String lastName);
   

   <select id="getEmployeeByIdAndName2" resultType="com.mybatis.entity.Employee">
       select *
       from employee
       where id = #{id}
         and last_name = #{lastName}
   </select>
   

5.4.3 参数封装

1. POJO

   如果多个参数是业务字段，可以通过传POJO，通过#{业务字段名称}来取值

2. Map

   如果多个参数不是业务字段，可以将多个参数封装为Map， 通过#{key}来取值

   <select id="getEmployeeByMap" resultType="com.mybatis.entity.Employee">
       select *
       from employee
       where id = #{p_id}
         and last_name = #{p_lastName}
   </select>
   

   Map<String, Object> paramMap = new HashMap<>();
   paramMap.put("p_id", 1);
   paramMap.put("p_lastName", "Chris");
   Employee employee = employeeMapper.getEmployeeByMap(paramMap);
   openSession.commit();
   

3. TO（Transfer Object）

   如果多个参数不是业务字段，但是经常使用，可能编写一个TO（Transfer Object）来传输数据

   Page{
    int index;
    int size;
   }
   

5.4.4 取值方式分析

1. 简单参数

   Employee getEmployeeByIdAndName(@Param("id") int id, String lastName);
   取id的值： #{id}或#{param1}
   取lastName的值：#{param2}
   

2. 对象参数

   Employee getEmployeeByIdAndEmp(@Param("id") int id, @Param("e")Employee emp);
   取id的值： #{id}或#{param1}
   取lastName的值：#{e.lastName}或者#{param2.lastName} --param2代表emp对象
   

3. 集合参数

   如果是Collection类型或者数组类型，会特殊处理，将Collection类型或者数组类型封装在map中

   Collection类型: key为collection, 如果是list会进一步封装key为list

   数组类型: key为array

   Employee getEmployeeByIds(List<int> ids);
   取第一个id的值：#{list[0]}
   

5.4.5 $和#的区别

1. $和#都可以用来获取参数

   #: 是以预编译的方式将参数设置到SQL中去，可以防止SQL注入，大多数情况下使用#取值

   $: 将取出的值直接拼装在SQL中，有SQL注入的安全风险

2. $ 可以用来动态设置SQL中的表名和字段名称,

   原生SQL不支持占位符的地方都可以用$来处理

   /**
    * 测试 testDynamicSql
    */
   @Test
   public void testDynamicSql() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession = sqlSessionFactory.openSession();
           EmployeeMapper employeeMapper = openSession.getMapper(EmployeeMapper.class);
   
           //map参数
           Map<String, Object> paramMap = new HashMap<>();
           paramMap.put("p_gender", "F");
           paramMap.put("tableName", "Employee");
           paramMap.put("sortFieldName", "last_name");
           paramMap.put("sort", "ASC");
   
           List<Employee> employees = employeeMapper.dynamicSql(paramMap);
           for (Employee employee : employees) {
               System.out.println(employee.toString());
           }
           openSession.commit();
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           if (null != openSession) {
               openSession.close();
           }
       }
   }
   

   <!--动态SQL-->
   <select id="dynamicSql" resultType="com.mybatis.entity.Employee">
       select *
       from ${tableName}
       where gender = #{p_gender}
       order by ${sortFieldName} ${sort}
   </select>
   

3. #{}可以规定参数的类型

   javaType, jdbcType, resultMap, typeHandler, jdbcTypeName

   jdbcType: 在数据为null的情况下，数据库不能识别mybatis对于null的处理比如Oracle

    <!-- 
    MyBatis将所有的null都映射为原生的 OTHER(Types.OTHER)
    Oracle无法处理Other类型
    需要指定字段值为空时的JDBC类型jdbcType=NULL
    或者在全局配置中设置 <setting name="jdbcTypeForNull" value="NULL"/>
    -->
   <insert id="addEmployeeWithNull" parameterType="com.mybatis.entity.Employee" databaseId="oracle">
       <selectKey keyProperty="id" order="BEFORE" resultType="Integer">
            select EMPLOYEES_SEQ.nextval from dual
       </selectKey>
         <!-- 插入时的主键是从序列中拿到 -->
         insert into employee (id, last_name, email, gender)
         values (#{id}, #{lastName}, #{email, jdbcType=NULL}, #{gender})
    </insert>
   

5.4.6 @的用法

    <if test="@cn.hutool.core.util.StrUtil@isNotEmpty(clientAdminBean.name) ">
        and a.name = #{clientAdminBean.name}
    </if>
    <if test="@cn.hutool.core.util.StrUtil@isNotEmpty(clientAdminBean.tableName) ">
        and a.table_name like CONCAT('%',#{clientAdminBean.tableName},'%')
    </if>
    <if test="@cn.hutool.core.util.StrUtil@isNotEmpty(clientAdminBean.mqTopic) ">
        and a.mq_topic like CONCAT('%',#{clientAdminBean.mqTopic},'%')
    </if>

5.5 返回结果封装

5.5.1 返回为集合

resultType为集合中元素的类型

5.5.2 返回为单个Map

resultType为的类型为map

<!--测试返回结果为map-->
<select id="getEmployeeReturnMap" resultType="map">
    select *
    from employee t
    where t.id = #{id}
</select>

/**
 * 测试 testMapResult
 */
@Test
public void testMapResult() throws IOException {
    SqlSessionFactory sqlSessionFactory;
    SqlSession openSession = null;
    try {
        sqlSessionFactory = getSqlSessionFactory();
        openSession = sqlSessionFactory.openSession();
        EmployeeMapper employeeMapper = openSession.getMapper(EmployeeMapper.class);

        Map<String, Object> employeeMap = employeeMapper.getEmployeeReturnMap(4);
        openSession.commit();
        for (Map.Entry<String, Object> entry : employeeMap.entrySet()) {
            System.out.println(entry.getKey() + ", " + entry.getValue());
        }
    } catch (IOException e) {
        e.printStackTrace();
        throw e;
    } finally {
        if (null != openSession) {
            openSession.close();
        }
    }
}

5.5.3 返回为多个Map

接口类

/**
  * 多条记录封装在Map<String, Employee>
  * MapKey 告诉mybatis用Employee的哪个属性作为map的key
  */
@MapKey("id")
Map<Integer, Employee> getEmployeeByGenderReturnMap(String gender);

SQL映射文件

<!--测试返回结果为多个MAP对象-->
<select id="getEmployeeByGenderReturnMap" resultType="com.mybatis.entity.Employee">
    select *
    from employee t
    where t.gender = #{gender}
</select>

/**
 * 测试返回为多个对象
 */
@Test
public void testMapResult2() throws IOException {
    SqlSessionFactory sqlSessionFactory;
    SqlSession openSession = null;
    try {
        sqlSessionFactory = getSqlSessionFactory();
        openSession = sqlSessionFactory.openSession();
        EmployeeMapper employeeMapper = openSession.getMapper(EmployeeMapper.class);

        //返回为多个对象
        Map<Integer, Employee> employeeMap = employeeMapper.getEmployeeByGenderReturnMap("F");

        openSession.commit();
        for (Map.Entry<Integer, Employee> entry : employeeMap.entrySet()) {
            System.out.println(entry.getKey() + ", " + entry.getValue());
        }
    } catch (IOException e) {
        e.printStackTrace();
        throw e;
    } finally {
        if (null != openSession) {
            openSession.close();
        }
    }
}

5.6 resultMap

5.6.1 resultType 入门

resultType 是自动封装，将表中的字段与JavaBean中的字段映射

resultMap 是自定义封装，实现高级结果集映射

1. 定义ResultMap

   <!--
   自定义表字段名称与JavaBean属性的映射
   type: JavaBean类型
   id: resultMap唯一标识，方便被引用
   -->
   <resultMap id="employeeMap" type="com.mybatis.entity.Employee">
       <!--
       column: 表字段名称
       property: JavaBean类型属性
       -->
       <id column="id" property="id"/>
       <result column="last_name" property="lastName"/>
       <result column="email" property="email"/>
       <result column="gender" property="gender"/>
       <!--不在此处配置的列，会自动映射，但如果使用resultMap,建议把所有列都配置出来-->
   
   </resultMap>
   
   <select id="getEmployeeByGenderReturnMap" resultMap="employeeMap">
       select *
       from employee t
       where t.gender = #{gender}
   </select>
   

2. 业务类

   /**
    * 多条记录封装在Map<String, Employee>
    * MapKey 告诉mybatis用Employee的哪个属性作为map的key
    */
   @MapKey("id")
   Map<Integer, Employee> getEmployeeByGenderReturnMap(String gender);
   

3. 测试类

   /**
    * 测试resultMap
    */
   @Test
   public void testResultMap() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession = sqlSessionFactory.openSession();
           EmployeeMapper2 employeeMapper2 = openSession.getMapper(EmployeeMapper2.class);
           Map<Integer, Employee> employeeMap = employeeMapper2.getEmployeeByGenderReturnMap("F");
           openSession.commit();
           for (Map.Entry<Integer, Employee> entry : employeeMap.entrySet()) {
               System.out.println(entry.getKey() + ", " + entry.getValue());
           }
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           if (null != openSession) {
               openSession.close();
           }
       }
   }
   

5.6.2 通过级联属性的方式进行联合查询

1. 定义ResultMap

   <!--通过级联属性的方式进行联合查询-->
   <resultMap id="empDeptMap" type="com.mybatis.entity.Employee">
       <id column="id" property="id"/>
       <result column="last_name" property="lastName"/>
       <result column="email" property="email"/>
       <result column="gender" property="gender"/>
       <result column="did" property="dept.id"/>
       <result column="department_name" property="dept.name"/>
   </resultMap>
   
   <select id="getEmpAndDept" resultMap="empDeptMap">
       select t.id, t.last_name, t.email, t.gender, d.id did, d.department_name
       from employee t,
            department d
       where t.id = #{id}
         and t.department_id = d.id
   </select>
   

2. 业务类

   @Data
   @AllArgsConstructor
   public class Employee {
   
       public Employee(String lastName, String email, String gender) {
           this.lastName = lastName;
           this.email = email;
           this.gender = gender;
       }
   
       public Employee(int id, String lastName, String email, String gender) {
           this(lastName, email, gender);
           this.id = id;
       }
   
       private int id;
       private String lastName;
       private String email;
       private String gender;
       private Department dept;
   }
   

3. 测试类

   /**
    * 通过级联属性的方式进行联合查询
    */
   @Test
   public void testAssociateResultMap() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession = sqlSessionFactory.openSession();
           EmployeeMapper2 employeeMapper2 = openSession.getMapper(EmployeeMapper2.class);
           Employee employee = employeeMapper2.getEmpAndDept(1);
           openSession.commit();
           System.out.println(employee.toString());
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           if (null != openSession) {
               openSession.close();
           }
       }
   }
   

5.6.3 使用association进行分步查询

1. SQL映射文件

   DepartmentMapper.xml

   <?xml version="1.0" encoding="UTF-8" ?>
   <!DOCTYPE mapper
           PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
           "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
   <mapper namespace="com.mybatis.dao.mapper.DepartmentMapper">
   
       <select id="getDeptById" resultType="com.mybatis.entity.Department">
            select * from department t where t.id=#{id}
        </select>
   
   </mapper>
   

   EmployeeMapper2.xml

   <!--使用association进行分步查询-->
   <resultMap id="empDeptBySteps" type="com.mybatis.entity.Employee">
       <id column="id" property="id"/>
       <result column="last_name" property="lastName"/>
       <result column="email" property="email"/>
       <result column="gender" property="gender"/>
       <!--
       1.先根据员工id查询到员工信息
       2.再根据员工信息中的d_id查询部门信息
       3.再将部门信息封闭到员工对象中
       select：表示当前关联的对象是调用指定的方式查询出来的结果
       column="department_id":指定传入select中方法的参数，此参数来自于第一个方法“getEmpById”中查询的结果集里面
       -->
       <association property="dept" javaType="com.mybatis.entity.Department"
                    select="com.mybatis.dao.mapper.DepartmentMapper.getDeptById" column="department_id"/>
   </resultMap>
   
   <select id="getEmpById" resultMap="empDeptBySteps">
       select * from employee t where t.id = #{id}
   </select>
   

2. 业务类

   @Data
   @AllArgsConstructor
   @NoArgsConstructor
   public class Department {
   
      private int id;
      private String name;
   }
   

   package com.mybatis.entity;
   
   import lombok.AllArgsConstructor;
   import lombok.Data;
   import lombok.NoArgsConstructor;
   
   @Data
   @AllArgsConstructor
   @NoArgsConstructor
   public class Employee {
   
       private int id;
       private String lastName;
       private String email;
       private String gender;
       private Department dept;
   
   
       public Employee(String lastName, String email, String gender) {
           this.lastName = lastName;
           this.email = email;
           this.gender = gender;
       }
   
       public Employee(int id, String lastName, String email, String gender) {
           this(lastName, email, gender);
           this.id = id;
       }
   
   
   }
   

3. 测试类

   /**
    * 使用association进行分步查询
    */
   @Test
   public void testEmpDeptBySteps() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession = sqlSessionFactory.openSession();
           EmployeeMapper2 employeeMapper2 = openSession.getMapper(EmployeeMapper2.class);
           Employee employee = employeeMapper2.getEmpById(1);
           openSession.commit();
           System.out.println(employee.toString());
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           if (null != openSession) {
               openSession.close();
           }
       }
   }
   

5.6.4 分步查询时延时加载

1. 全局配置文件

   <!--开启全局延时加载-->
   <setting name="lazyLoadingEnabled" value="true"/>
   <!--关闭积极加载-->
   <setting name="aggressiveLazyLoading" value="false"/>
   <setting name="lazyLoadTriggerMethods" value=""/>
   

2. 业务类

   一般业务类中使用@Data注解会触发toString方法,可以将@Data替换成@Getter和@Setter注解

   package com.mybatis.entity;
   
   import lombok.AllArgsConstructor;
   import lombok.Data;
   import lombok.Getter;
   import lombok.NoArgsConstructor;
   import lombok.Setter;
   
   @Getter
   @Setter
   @AllArgsConstructor
   @NoArgsConstructor
   public class Employee {
   
      private int id;
      private String lastName;
      private String email;
      private String gender;
      private Department dept;
   
   
      public Employee(String lastName, String email, String gender) {
         this.lastName = lastName;
         this.email = email;
         this.gender = gender;
      }
   
      public Employee(int id, String lastName, String email, String gender) {
         this(lastName, email, gender);
         this.id = id;
      }
   }
   

5.6.5 使用Collection 关联集合查询

1. SQL映射文件

   <!--嵌套结果集关联查询-->
     <resultMap id="deptWithEmps" type="com.mybatis.entity.Department">
         <id column="did" property="id"/>
         <result column="name" property="name"/>
         <!--
         定义集合类型的属性
         ofType:指定集合里面的元素类型
         -->
         <collection property="emps" ofType="com.mybatis.entity.Employee">
             <id column="id" property="id"/>
             <result column="last_name" property="lastName"/>
             <result column="email" property="email"/>
             <result column="gender" property="gender"/>
         </collection>
     </resultMap>
   
     <select id="getDeptById2" resultMap="deptWithEmps">
   	SELECT d.id did, d.department_name, e.id, e.email, e.gender, e.last_name, e.department_id
         FROM department d
       LEFT JOIN employee e ON e.department_id = d.id
       WHERE d.id = #{id}
     </select>
   

2. 业务类

   @Data
   @AllArgsConstructor
   @NoArgsConstructor
   public class Department {
   
       private int id;
       private String name;
       private List<Employee> emps;
   }
   

3. 测试类

   /**
    * 使用collection进行关联对象的集合查询
    */
   @Test
   public void testDeptWithEmps() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession = sqlSessionFactory.openSession();
           DepartmentMapper departmentMapper = openSession.getMapper(DepartmentMapper.class);
           Department dept = departmentMapper.getDeptById2(1);
           openSession.commit();
           System.out.println(dept.toString());
           System.out.println(dept.getEmps().toString());
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           if (null != openSession) {
               openSession.close();
           }
       }
   }
   

5.6.6 使用Collection 分步和延时查询

1. SQL映射文件

   DepartmentMapper.xml

   
   <!--
   分步查询部门下的员工信息
   1.先查询出部门信息
   2.再根据部门ID查询出员工信息
   -->
   <resultMap id="deptWithEmpsByStep" type="com.mybatis.entity.Department">
       <id column="id" property="id"/>
       <result column="department_name" property="name"/>
       <!--
       column="id":指定传入select中方法的参数，此参数来自于第一个方法“getDeptByIdStep”中查询的结果集里面
       多个参数时column={key1=value1,key2=value2} key要和也分步查询方法里面的参数名称保持一致
       javaType:返回结果集的类型
       fetchType: 即使全局打开了延时加载，也可以指定针对此关联查询是否要进行延时加载，
                  eager：立即加载，lazy:延时加载
       -->
       <collection property="emps" select="com.mybatis.dao.mapper.EmployeeMapper.getEmployeeByDeptId" column="id"
                   javaType="List" fetchType="lazy"/>
   </resultMap>
   <select id="getDeptByIdStep" resultMap="deptWithEmpsByStep">
       select * from department t where t.id=#{id}
   </select>
   

   EmployeeMapper.xml

   <!--
   分步查询部门下的员工信息
   1.先查询出部门信息
   2.再根据部门ID查询出员工信息
   -->
   <select id="getEmployeeByDeptId" resultType="com.mybatis.entity.Employee">
       select *
       from employee
       where department_id = #{department_id}
   </select>
   

2. 业务类

   package com.mybatis.dao.mapper;
   
   import com.mybatis.entity.Employee;
   import org.apache.ibatis.annotations.MapKey;
   import org.apache.ibatis.annotations.Param;
   
   import java.util.List;
   import java.util.Map;
   
   public interface EmployeeMapper {
       Employee getEmployeeByDeptId(int i);
   }
   

3. 测试类

   /**
    * 使用collection进行关联对象的集合分步查询
    */
   @Test
   public void testDeptWithEmpsBySteps() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession = sqlSessionFactory.openSession();
           DepartmentMapper departmentMapper = openSession.getMapper(DepartmentMapper.class);
           Department dept = departmentMapper.getDeptByIdStep(2);
           openSession.commit();
           System.out.println(dept.toString());
           System.out.println(dept.getEmps().toString());
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           if (null != openSession) {
               openSession.close();
           }
       }
   }
   

5.6.7 鉴别器

1. SQL映射文件

   EmployeeMapper2

   <!--
     discriminator
     鉴别器
     mybatis可以根据discriminator判断某列的值，根据值来改变封装行为
     封装employee
     1.如果查询出来的是女生，则把对应的部门信息查询出来，否则不查询
     2.如果查询出来的是男生，则把lastName这一列赋值到email上
     -->
   <resultMap id="empDeptByStepsWithDiscriminator" type="com.mybatis.entity.Employee">
       <id column="id" property="id"/>
       <result column="last_name" property="lastName"/>
       <result column="email" property="email"/>
       <result column="gender" property="gender"/>
       <!--如果查询出来的是女生，则把对应的部门信息查询出来，否则不查询-->
       <discriminator javaType="String" column="gender">
           <case value="F" resultType="com.mybatis.entity.Employee">
               <association property="dept" select="com.mybatis.dao.mapper.DepartmentMapper.getDeptById"
                            javaType="com.mybatis.entity.Employee"
                            column="department_id" fetchType="eager"/>
           </case>
   
           <!--如果查询出来的是男生，则把lastName这一列赋值到email上-->
           <case value="M" resultType="com.mybatis.entity.Employee">
               <id column="id" property="id"/>
               <result column="last_name" property="lastName"/>
               <result column="last_name" property="email"/>
               <result column="gender" property="gender"/>
           </case>
       </discriminator>
   </resultMap>
   
   <select id="getEmpByIdwithDiscriminator" resultMap="empDeptByStepsWithDiscriminator">
       select * from employee
   </select>
   

   DepartmentMapper.xml

   <select id="getDeptById" resultType="com.mybatis.entity.Department">
        select id, department_name name from department t where t.id=#{id}
   </select>
   

2. 业务类

   public interface EmployeeMapper2 {
       List<Employee> getEmpByIdwithDiscriminator();
   }
   

3. 测试类

   @Test
   public void testEmpByUsingDiscriminator() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession = sqlSessionFactory.openSession(true);
           EmployeeMapper2 employeeMapper2 = openSession.getMapper(EmployeeMapper2.class);
           List<Employee> emps = employeeMapper2.getEmpByIdwithDiscriminator();
           for (Employee emp : emps) {
               System.out.println(emp.toString());
               if (null != emp.getDept()) {
                   System.out.println(emp.getDept().toString());
               }
           }
   
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           if (null != openSession) {
               openSession.close();
           }
       }
   }
   

4. 结果

   Employee{id=1, lastName='Chris', email='Chris', gender='M'}
   Employee{id=3, lastName='Hedy', email='Hedy', gender='M'}
   Employee{id=4, lastName='Nancy', email='Nancy@gmail.com', gender='F'}
   Department(id=1, name=开发部, emps=null)
   Employee{id=7, lastName='Cano', email='Cano@gmail.com', gender='F'}
   Department(id=2, name=测试部, emps=null)
   

5.7 动态SQL

5.7.1 if

<select id="getempsbyconditionIf" resultType="com.mybatis.entity.Employee">
    select * from employee t
    <!--
    where:用来封装查询条件，会将SQL中多出来的and和or去掉,但是只去掉第一个and和or
    -->
    <where>
        /* 1. test:判断表达式，使用OGNL表达式
        https://commons.apache.org/proper/commons-ognl/language-guide.html
        遇见特殊符号应该转为转义字符*/
        <if test="id != null">
            t.id = #{id}
        </if>
        <if test="lastName != null and lastName!= '' ">
            and t.last_name=#{lastName}
        </if>
        <if test="email != null and email.trim() !='' ">
            and t.email=#{email}
        </if>
        <if test='gender != null and (gender =="F" || gender =="M")'>
            and t.gender=#{gender}
        </if>
    </where>
</select>

5.7.2 trim

<select id="getempsbyconditionTrim" resultType="com.mybatis.entity.Employee">
    select * from employee t

    <!--
        prefix: 对trim中整个字符串拼串后的结果加一个前缀
        prefixOverrides: 前缀覆盖，去掉整个拼串前面多余的字符串
        suffix: 对trim中整个字符串拼串后的结果加一个后缀
        suffixOverrides: 后缀覆盖，去掉整个拼串前面多余的字符串
    -->
    <trim prefix="where" suffixOverrides="and">
        <if test="id != null">
            t.id = #{id} and
        </if>
        <if test="lastName != null and lastName!= '' ">
            t.last_name=#{lastName} and
        </if>
        <if test="email != null and email.trim() !='' ">
            t.email=#{email} and
        </if>
        <if test='gender != null and (gender =="F" || gender =="M")'>
            t.gender=#{gender}
        </if>
    </trim>
</select>

5.7.3 choose

<select id="getempsbyconditionChoose" resultType="com.mybatis.entity.Employee">
    select * from employee t
    <where>
        <choose>
            <when test="id!=null">id=#{id}</when>
            <when test="lastName!=null">last_name=#{lastName}</when>
            <when test="email!=null and email.trim()!='' ">email=#{email}</when>
            <otherwise>
                <!--查询所有-->
                1 = 1
            </otherwise>
        </choose>
    </where>
</select>

<select id="getRolePrincileByFormIdandRoleKey" resultMap="BaseResultMap">
        SELECT
        <include refid="Base_Column_List"/>
        FROM
        t_wf_role_principle p
        WHERE
        p.formId = #{formId}
        <choose>
            <when test="null != roleKeys and roleKeys.size > 1">
                <foreach collection="roleKeys" item="key" open=" and p.roleKey in (" close=")"
                         separator=",">
                    #{key}
                </foreach>
            </when>
            <when test="null != roleKeys and roleKeys.size == 1">
                and p.roleKey = #{roleKeys[0]}
            </when>
        </choose>
</select>

5.7.4 set

<!--
参数中带了哪一个参数则更新此参数对应的字段
<set>用来封装修改字段
也可以用tirm替换set标签
<trim prefix="set" prefixOverrides=",">
-->
<update id="updateEmp">
    update employee t
    <set>
        <if test="lastName!=null and lastName.trim()!=''">
            t.last_name=#{lastName},
        </if>
        <if test="email!=null and email.trim()!=''">
            t.email=#{email},
        </if>
        <if test='gender!=null and  (gender =="F" || gender =="M")'>
            t.gender=#{gender},
        </if>
    </set>
    where t.id = #{id}
</update>

5.7.5 foreach

<!--
   connection:指定要遍历的集合名称
        list类型的参数会特殊处理封装在map中,这个map的key名称是list
   item:将当前遍历出的值赋值给指定变更
   separator元素之间的分隔符
   open：封装遍历结果的开始字符
   close：封装遍历结果的结束字符
   index:索引，遍历list时，index是当前元素的索引，item为当前元素的值
         遍历map时，index是当前元素的key，item为当前元素的值
   #{变量名}就能取出变量的值也就是当前遍历出的元素
-->
<select id="getEmpsByConditionForeach" resultType="com.mybatis.entity.Employee">
    select * from employee where id in
    <foreach collection="list" item="id" separator="," open="(" close=")" index="inx">
        #{id}
    </foreach>
</select>

public interface DynamicSqlMapper {
    List<Employee> getEmpsByConditionForeach(List<Integer> ids);
}

/**
 * 测试foreach
 */
@Test
public void testForeach() throws IOException {
    SqlSessionFactory sqlSessionFactory;
    SqlSession openSession = null;
    try {
        sqlSessionFactory = getSqlSessionFactory();
        openSession = sqlSessionFactory.openSession(true);
        DynamicSqlMapper dynamicSqlMapper = openSession.getMapper(DynamicSqlMapper.class);
        List<Employee> employees = dynamicSqlMapper.getEmpsByConditionForeach(Arrays.asList(1, 3, 4));
        openSession.commit();
        for (Employee employee : employees) {
            System.out.println(employee.toString());
        }
    } catch (IOException e) {
        e.printStackTrace();
        throw e;
    } finally {
        if (null != openSession) {
            openSession.close();
        }
    }
}

5.7.6 foreach insert for mysql

方式一

1. SQL映射文件

   <insert id="addEmpsInBatch">
       insert into employee (last_name, email,gender,department_id)
       <foreach collection="emps" item="emp" open="values" separator=",">
           (#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
       </foreach>
   </insert>
   

2. 业务类

   int addEmpsInBatch(@Param("emps") List<Employee> employees);
   

3. 测试类

   /**
    * 测试foreach insert
    */
   @Test
   public void testForeachInsert() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession = sqlSessionFactory.openSession(true);
           DynamicSqlMapper dynamicSqlMapper = openSession.getMapper(DynamicSqlMapper.class);
           Employee emp1 = new Employee("S4", "s4@gmail.com", "F", new Department(1));
           Employee emp2 = new Employee("S5", "s5@gmail.com", "M", new Department(2));
           Employee emp3 = new Employee("S6", "s6@gmail.com", "F", new Department(2));
           int count = dynamicSqlMapper.addEmpsInBatch(Arrays.asList(emp1, emp2, emp3));
           System.out.println("new added employee count:" + count);
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           if (null != openSession) {
               openSession.close();
           }
       }
   }
   

方式二

1. SQL映射文件

   <!-- Caused by: java.sql.SQLSyntaxErrorException: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'insert into employee (last_name, email,gender,department_id)values
    (' at line 4
    需要打开MYSQL的批量写入模式:allowMultiQueries=true
       jdbc.home.url=jdbc:mysql://192.168.101.127:3306/chris?allowMultiQueries=true&useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=CTT
    -->
    <insert id="addEmpsInBatch2">
        <foreach collection="emps" item="emp"  separator=";">
            insert into employee (last_name, email,gender,department_id)values
            (#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
        </foreach>
    </insert>
   

5.7.7 foreach insert for oracle

1. SQL中映射文件

   <!--
    oracle 不支持mysql这种批量写入数据库
    insert into employee(last_name, email,gender,department_id) values (),()
    但是支持如下三种
    1. 将多条语句放在begin和end之间
    begin
       insert into employee(last_name, email,gender,department_id) values ();
       insert into employee(last_name, email,gender,department_id) values ();
       insert into employee(last_name, email,gender,department_id) values ();
    end;
    2. 利用中间表
        insert into employee(last_name, email,gender,department_id) select employees_seq.nextval, last_name, email from (
           select 'test_a_01' last_name, 'test_a_01@163.com' email from dual;
           union
           select 'test_a_02' last_name, 'test_a_02@gmail.com' email from dual;
           union
           select 'test_a_03' last_name, 'test_a_03@gmail.com' email from dual;
        )
   -->
   
   <!--1. 将多条语句放在begin和end之间-->
   <insert id="addEmpsInBatchInOracle" databaseId="oracle">
       <foreach collection="emps" item="emp" open="begin" close="end;" separator=";">
           insert into employee (last_name, email,gender,department_id)
           (#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
       </foreach>
   </insert>
   
   <!--2. 利用中间表-->
   <insert id="addEmpsInBatch2InOracle" databaseId="oracle">
       insert into employee(last_name, email,gender,department_id)
       <foreach collection="emps" item="emp"
                open="select employees_seq.nextval, last_name, email, gender, department_id from(" close=")"
                separator="union">
           select #{emp.lastName} last_name, #{emp.email} email, #{emp.gender} gender, #{emp.dept.id} department_id
           from dual;
       </foreach>
   
   </insert>
   

5.7.8 内置参数

<!--
两个内置参数
1. _parameter: 代表传入方法的整个参数
    如果是一个参数，_parameter就表示这个参数
    如果是多个参数，参数会被mybatis封装成为一个map，_parameter就代表这个map
2. _databaseId: 如果配置了databaseIdProvider,_databaseIdy就是代表当前使用的数据库别名
-->

<!--根据当启用的数据库来进行不同的查询-->
<select resultType="com.mybatis.entity.Employee">
    <if test="_databaseId=='mysql'">
        select * from employee
        <where>
            <if test="_parameter!=null">
                last_name = #{_parameter.lastName}
            </if>
        </where>

    </if>
    <if test="_databaseId=='mysql'">
        select * from t_employee
    </if>

</select>

5.7.9 bind

1. SQL映射文件

   <!--如果lastName有值则进行模糊查询-->
   <select id="getEmpByBind" resultType="com.mybatis.entity.Employee">
       <!--bind 将OGNL表达式的值绑定到一个变量中，方便后面引用这个变量的值-->
       <bind name="_lastName" value="'%'+lastName+'%'"/>
       select * from employee
       <where>
           <if test="_parameter != null and lastName !='' ">
               last_name LIKE #{_lastName}
           </if>
       </where>
   </select>
   

2. 业务类

   public interface DynamicSqlMapper {
       List<Employee> getEmpByBind(Employee emp);
   }
   

3. 测试类

   /**
    * 测试bind
    */
   @Test
   public void testBind() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession = sqlSessionFactory.openSession(true);
           DynamicSqlMapper dynamicSqlMapper = openSession.getMapper(DynamicSqlMapper.class);
           Employee emp = new Employee();
           // 查询名称中包括a的员工记录
           emp.setLastName("a");
   
           List<Employee> emps = dynamicSqlMapper.getEmpByBind(emp);
           for (Employee employee : emps) {
               System.out.println(employee.toString());
           }
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           if (null != openSession) {
               openSession.close();
           }
       }
   }
   

5.8.0 sql片断

1. SQL映射文件

   <!--
   include 
   1.可以引用sql标签中定义的SQL片断
   2.可以定义属性变量，可以在sql标签使用${testColumn}来获取属性变量的值
   -->
   <insert id="addEmpsWithCondistionInclude">
       insert into employee (
       <include refid="emp_insert_fields">
           <property name="testColumn" value="abc"/>
       </include>
       )
       <foreach collection="emps" item="emp" open="values" separator=",">
           (#{emp.lastName},#{emp.email},#{emp.gender},#{emp.dept.id})
       </foreach>
   </insert>
   
   <!--
   sql标签用来抽取可重用的sql片段
   1.将常用的列名抽取出来，方便查询或插入中引用
   2.include来引用sql标签中的sql片断
   -->
   <sql id="emp_insert_fields">
       last_name, email,gender,department_id,${testColumn}
   </sql>
   

6 缓存

6.1 mybatis 缓存

mybatis中默认定义了两级缓存

默认情况有只开启一级缓存，也称为本地缓存，即SqlSesssion级别的缓存

二级缓存为全局缓存，需要手动配置和开启，它是基于namespace级别的缓存

为了提高扩展性，mybatis提供了缓存接口Cache，可以通过实现Cache接口来实现二级缓存

6.2 一级缓存

与数据库同一次会话期间查询到的数据会放在一级缓存中，以后如果需要获取相同的数据，直接从一级缓存中查

6.2.1 使用一级缓存

1. SQL映射

   <select id="getEmpById" resultType="com.mybatis.entity.Employee">
       select * from employee where id = #{id}
   </select>
   

2. 测试类

   /**
    * 测试Cache
    */
   @Test
   public void testCache() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession = sqlSessionFactory.openSession(true);
           CacheMapper cacheMapper = openSession.getMapper(CacheMapper.class);
   
           // 第一次查询
           Employee emp = cacheMapper.getEmpById(1);
           System.out.println(emp.toString());
   
           // 第二次查询
           Employee emp2 = cacheMapper.getEmpById(1);
           System.out.println(emp2.toString());
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           if (null != openSession) {
               openSession.close();
           }
       }
   }
   

3. 测试结果

   DEBUG - ==>  Preparing: select * from employee where id = ?
   DEBUG - ==> Parameters: 1(Integer)
   DEBUG - <==      Total: 1
   Employee{id=1, lastName='Chris', email='chris@gmail.com', gender='M'}
   Employee{id=1, lastName='Chris', email='chris@gmail.com', gender='M'}
   

6.2.2 一级缓存失效

1. SqlSession不是同一个，则一级缓存失效

2. SqlSession相同，但是需要查询的数据在一级缓存中没有，则不走缓存，需要去数据库中查询

3. SqlSession相同，但是两次查询中间有增删改的SQL操作，因为mybatis认为增删改可能对之后的查询有影响

4. SqlSession相同，但是手动清除了一级缓存

   openSession.clearCache();
   

6.3 二级缓存

6.3.1 工作机制

1. 一个会话查询一条数据，这条数据会被放在当前会话的一级缓存中

2. 如果当前会话关闭，此会话对应的一级缓存中的数据会被保存到二级缓存中，新的会话查询信息时，就会参照二级缓存

3. 如果sqlsession即有employee信息又有department信息，二级缓存会根据不同对象信息的namespace缓存数据

   EmployeeMapper -> employee

   DeapartmentMapper-> department

6.3.2 使用二级缓存

1. 全局配置文件中开启二级缓存

   <!--全局开启二级缓存,默认已开启-->
   <setting name="cacheEnabled" value="true"/>
   

2. 需要使用二级缓存的映射文件处使用cache配置缓存

   <cache />
   

3. POJO需要实现序列化接口

   public class Department implements Serializable 
   

   public class Employee implements Serializable
   

4. 测试类

   查出的数据都会先放在一级缓存中

   只有会话被关闭，一级缓存中的数据才会转移到二级缓存中，其它SqlSesssion才能在二级缓存中获取此数据

   /**
    * 测试二级缓存
    */
   @Test
   public void testSecondCache() throws IOException {
       SqlSessionFactory sqlSessionFactory;
       SqlSession openSession_1 = null;
       SqlSession openSession_2 = null;
       try {
           sqlSessionFactory = getSqlSessionFactory();
           openSession_1 = sqlSessionFactory.openSession(true);
           CacheMapper cacheMapper1 = openSession_1.getMapper(CacheMapper.class);
   
           openSession_2 = sqlSessionFactory.openSession(true);
           CacheMapper cacheMapper2 = openSession_2.getMapper(CacheMapper.class);
   
           // 第一次查询
           Employee emp = cacheMapper1.getEmpById(1);
           System.out.println(emp.toString());
           // 查出的数据都会先放在一级缓存中，只有会话被关闭，一级缓存中的数据才会转移到二级缓存中，其它opensesssion才能在二级缓存中获取
           closeSession(openSession_1);
   
           // 第二次查询
           Employee emp2 = cacheMapper2.getEmpById(1);
           System.out.println(emp2.toString());
           closeSession(openSession_2);
       } catch (IOException e) {
           e.printStackTrace();
           throw e;
       } finally {
           closeSession(openSession_1, openSession_2);
       }
   }
   

5. 结果

   DEBUG - Cache Hit Ratio [com.mybatis.dao.mapper.CacheMapper]: 0.5

   DEBUG - ==>  Preparing: select * from employee where id = ?
   DEBUG - ==> Parameters: 1(Integer)
   DEBUG - <==      Total: 1
   Employee{id=1, lastName='Chris', email='chris@gmail.com', gender='M'}
   DEBUG - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@27c6e487]
   DEBUG - Returned connection 667346055 to pool.
   DEBUG - Cache Hit Ratio [com.mybatis.dao.mapper.CacheMapper]: 0.5
   Employee{id=1, lastName='Chris', email='chris@gmail.com', gender='M'}
   

6.4 和缓存有关的配置

6.4.1 cacheEnabled

全局开启二级缓存,默认已开启 ,

false:仅关闭二级缓存，但是一级缓存仍然可用

<setting name="cacheEnabled" value="true"/>

6.4.2 useCache

每一个select标签都有一个useCache="true"

ture: 表示使用二级缓存，但是必须将全局二级缓存打开

false:表示不使用二级缓存，但一级缓存仍然可用

<select id="getEmpById" resultType="com.mybatis.entity.Employee" useCache="true">
    select * from employee where id = #{id}
</select>

6.4.3 flushCache

1. 每一个查询标签都有一个flushCache="fase",如何改为flushCache="true"表示查询执行完之后都会清除一级和二级缓存

2. 每一个增删改标签都有一个flushCache="true",表示增删改执行完之后都会清除一级和二级缓存

   测试
   虽然去缓存中找数据，但是数据已经被清除

   DEBUG - ==>  Preparing: select * from employee where id = ?
   DEBUG - ==> Parameters: 1(Integer)
   DEBUG - <==      Total: 1
   Employee{id=1, lastName='Chris', email='chris@gmail.com', gender='M'}
   DEBUG - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@27c6e487]
   DEBUG - Returned connection 667346055 to pool.
   DEBUG - Opening JDBC Connection
   DEBUG - Checked out connection 667346055 from pool.
   DEBUG - ==>  Preparing: insert into employee ( last_name, email, gender, department_id ) values (?,?,?,?)
   DEBUG - ==> Parameters: shawn(String), shawn@qq.com(String), M(String), 1(Integer)
   DEBUG - <==    Updates: 1
   DEBUG - Cache Hit Ratio [com.mybatis.dao.mapper.CacheMapper]: 0.5
   DEBUG - ==>  Preparing: select * from employee where id = ?
   DEBUG - ==> Parameters: 1(Integer)
   DEBUG - <==      Total: 1
   Employee{id=1, lastName='Chris', email='chris@gmail.com', gender='M'}
   DEBUG - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@27c6e487]
   DEBUG - Returned connection 667346055 to pool.
   

   flushCache="false"

   增删改后，查询时会使用二级缓存

   DEBUG - ==>  Preparing: select * from employee where id = ?
   DEBUG - ==> Parameters: 1(Integer)
   DEBUG - <==      Total: 1
   Employee{id=1, lastName='Chris', email='chris@gmail.com', gender='M'}
   DEBUG - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@27c6e487]
   DEBUG - Returned connection 667346055 to pool.
   DEBUG - Opening JDBC Connection
   DEBUG - Checked out connection 667346055 from pool.
   DEBUG - ==>  Preparing: insert into employee ( last_name, email, gender, department_id ) values (?,?,?,?)
   DEBUG - ==> Parameters: shawn(String), shawn@qq.com(String), M(String), 1(Integer)
   DEBUG - <==    Updates: 1
   DEBUG - Cache Hit Ratio [com.mybatis.dao.mapper.CacheMapper]: 0.5
   Employee{id=1, lastName='Chris', email='chris@gmail.com', gender='M'}
   DEBUG - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@27c6e487]
   DEBUG - Returned connection 667346055 to pool.
   

6.4.5 SqlSession.clearCache()

只清空一级缓存，不会清空二级缓存，因为clearCache方法属于sqlsession级的方式，不是namesapce级别的方式

6.4.6 localCacheScope

<!--
本地缓存作用域,默认 SESSION
SESSION | STATEMENT
1.SESSION：当前会话sqlsession的所有查询数据都会被缓存
2.STATEMENT:同一会话的两次不同的sql间不会共享数据发，即可以禁用一级缓存
-->
<setting name="localCacheScope" value="SESSION"/>

6.5 缓存原理

6.6 mybatis整合ehcache

6.6.1 ehcache 源码

https://github.com/mybatis/ehcache-cache

6.6.2 官方文档

http://mybatis.org/ehcache-cache/

6.6.3 集成步骤

1. 改pom

   <dependency>
       <groupId>org.mybatis.caches</groupId>
       <artifactId>mybatis-ehcache</artifactId>
       <version>${mybatis.ehcache.version}</version>
       <exclusions>
           <exclusion>
               <groupId>org.slf4j</groupId>
               <artifactId>slf4j-api</artifactId>
           </exclusion>
       </exclusions>
   </dependency>
   

2. 建ehcache.xml

   <?xml version="1.0" encoding="UTF-8"?>
   <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
   
       <!--
          属性说明：
           diskStore：指定数据在磁盘中的存储位置。
           defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略
   
          以下属性是必须的：
           maxElementsInMemory - 在内存中缓存的element的最大数目
           maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大
           eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断
           overflowToDisk - 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上
   
          以下属性是可选的：
           timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大
           timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大
           diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.
           diskPersistent - 在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。
           diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作
           memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候， 移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）
           -->
   
       <!-- 磁盘保存路径 -->
       <diskStore path="D:\\ehcache"/>
       <defaultCache
               maxElementsInMemory="10000"
               maxElementsOnDisk="10000000"
               eternal="false"
               overflowToDisk="true"
               timeToIdleSeconds="120"
               timeToLiveSeconds="120"
               diskExpiryThreadIntervalSeconds="120"
               memoryStoreEvictionPolicy="LRU">
       </defaultCache>
   </ehcache>
   
   

3. 在SQL映射文件中引入ehcache实现类

   <!--
    type：自定义缓存的全类名，自定义缓存需要实现Cache接口
    -->
   <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
   

6.7 mybatis整合Spring

6.7.1 官方源码

https://github.com/mybatis/spring

6.7.2 官方文档

http://mybatis.org/spring/

6.7.3 版本兼容

官网地址

MongoDB 官网地址：https://www.mongodb.com/

MongoDB 官方英文文档：https://www.mongodb.com/docs/v5.0/

https://www.mongodb.com/docs/v5.0/reference/operator/query/#std-label-query-selectors

概述

MongoDB是由C++编写的基于分布式文件存储的数据库，旨在为web应用提供可扩展高性能的数据存储解决方案。

特点

1. 数据结构非常宽松，类似Json的Bson格式，因此可以存储比较复杂的数据类型
2. 查询语言非常强大，语法类似面向对象查询语言几乎可以实现类似关系型数据库单表查询的大部分功能
3. 支持对数据建立索引
4. 支持强事务，但只 支持单条事务不支持集合事务
5. 支持多种语言，如RUBY, PYTHON, JAVA, C++, PHP等
6. 支持复制，故障恢复和分片

应用场景

1. 游戏应用： 使用云数据库MongoDB作为游戏服务器的数据库存储用户信息。 用户的游戏装备，积分等直接以内嵌文档的形式存储，方便进行查询和和更新。
2. 物流应用： 用云数据库MongoDB存储订单信息，订单状态运送过程中不断更新，用云数据库MongoDB内嵌数组的形式来存储，一次查询就能将订单所有的变更读取出来，方便快捷且一目了然。
3. 社交应用：使用云数据库MongoDB存储用户发表的朋友圈信息，聊天记录，因为它提供了非常丰富的查询，并在写入和读取方面都相对较快
4. 大数库应用：使用云数据库MongoDB随时进行数据提取分析，掌握行业动态。

相辅相成

关系型数据库和非关系型数据是相辅相成了

关系型数据库的强事务特性在非关系型数据是没有的，所以一些关键的核心业务数据还是要存储在关系型数据库中，比如用户的订单，帐户金额等

对于一些查询写入速度要求高但对事务要求不高的数据可以放到非关系型数据中去存储

历史

1. 2009年2月，MongoDB首次在数据库领域亮相，打破了关系性数据库一统天下的局面

2. 2010年8月，MongoDB1.6版本发布，最大的一个功能就是支持Sharding自动分片

3. 2014年12月，MongoDB 3.0版本发布，由于收购了WiredTiger存储引擎，大幅提升了MongoDB写入性能

4. 2015年12月，MongoDB3.2版本发布，开始支持关联查询，查以一次性查询多个MongoDB集合

5. 2016年，MongoDB推出Atlas, 在AWS, Azure和GCP上的MongoDB托管服务

6. 2017年10月，MongoDB成功在纳斯达克上市

7. 2018年6月， MongoDB4.0版本发布推出ACID事务支持，成为第一个支持强事务的NOSQL数据库

安装

传统安装

下载

http://mongodb.com/try/download/community

bin目录

bin目录用来存放启动和关闭的脚本

install_compass 是来用安装compass工具
mongo是用来启动mongodb客户端
mongod是用来启动mongo服务的启动脚本
mongos路由脚本

启动mongodb

mkdir ../datas ../logs

./mongod --port=27017 --dbpath=../data --logpath=../logs/mongo.log
--port 指定服务监听商品号默认27017
--dbpath  指定mongodb数据存放目录，启动时目录必须存在
--logpath 指定mongodb日志文件存放位置

./mongod --help

docker安装

搜索mongo

进入 mongo

[root@master ~]# docker search mongo
[root@master ~]# docker pull mongo:5.0.5
[root@master ~]# docker run -d --name="mongo" -p 27017:27017 mongo:5.0.5
[root@master ~]# docker exec -it mongo /bin/bash

root@a4634a4f15c7:/# mongo	 ##启动mongdodb
> show dbs;
admin   0.000GB
config  0.000GB
local   0.000GB
> exit  ##只是退出当前mongodb的客户端
bye
root@a4634a4f15c7:/# 

核心概念

库-DataBase

mongodb中的库的概念类似于传统关系型数据库中库的概念，用来隔离不同应用的数据
mongodb中可以创建多个库，每一个库都有自己的集合和权限，不同的数据库放置在不同的文件中
默认数据库为test，数据存储在启动时指定的目录中。

集合-Collection

集合就是MongoDB中文档组，类似于关系型数据库中表的概念
集合存在于数据库中，一个库可以有多个集合，每个集合没有固定的结构，这意味着可以对集合插入不同格式和类型的数据，但通常情况下插入集合的数据都会有一定的关联性

文档-Document

文档是集合中的一条条记录，是一组键值key-value对即Bson. 
MongoDB的文档不需要设置相同的字段，并且相同的字段不需要相同的类型，这与关系型数据库有很大的区分，也是MongoDB非常突出的特点。

一个简单的文档如下：

{"site":"www.baidu.com", "name":"chris"}

关系总结

库操作

1. 查询所有库

show dbs; | show databases;

db 查询当前所在的库

> show dbs;
admin   0.000GB
config  0.000GB
local   0.000GB
> db
test
> use chris
switched to db chris
> show dbs;
admin   0.000GB
config  0.000GB
local   0.000GB
> db.users.insert({'name':'chris'})
WriteResult({ "nInserted" : 1 })
> show dbs;
admin   0.000GB
chris   0.000GB
config  0.000GB
local   0.000GB

admin: 从权限的角度来看，这人是root 数据库，要是将一个用户添加到这个数据库，这个用户自动继承所有的数据库权限，一些特殊的服务器端命令也只能从这个数据库运行，比如列出所有数据库或者关闭服务器。

local: 这个数据永远不会被复制，可以用来存储限于本地单台服务器的任意集合

config: 当MongoDB分片设置时，config数据库在内部使用，用于保存分片相关的信息

当打开客户端时默认连接是test库

root@a4634a4f15c7:/# mongo
MongoDB shell version v5.0.5

2. 创建数据库

当库存在时切换库，库不存在时创建并使用库，当库里面没有数据默念不显示这个库

use 数据库名称

3. 删除当前库

   db.dropDatabase();

   > db
   chris
   > db.dropDatabase()
   { "ok" : 1 }
   > db
   chris
   

集合操作

1. 查看库中的集合

   show collections | show tables

> show collections;
users
> show tables;
users

2. 创建集合

   db.createCollection('集合名称'，[options])

> db.createCollection('users');
{
        "ok" : 0,
        "errmsg" : "Collection already exists. NS: chris.users",
        "code" : 48,
        "codeName" : "NamespaceExists"
}
> db.createCollection('products');
{ "ok" : 1 }

options:

字段	类型	描述
capped	布尔	如果为ture必须指定size参数，则创建固定集合，固定集合是指有固定大小的集合，当达到最大值时，会自动覆盖掉最最早的文档。
size	数值	为固定集合指定一个最大值，即字节数
max	数值	指定固定集合中包含文档的最大数量

当集合不存在时，向集合中插入文档也会自动创建集合

3. 删除集合

   db.集合名称.drop();

   db.orders.drop();
   

文档操作

https://docs.mongodb.com/manual/reference/method

https://www.mongodb.com/docs/v5.0/crud/

文档插入

单条

db.集合名称.insert({name:'chris',age:12})

多条

db.集合名称.insertMany(
	[<doc1>,<doc2>],
    {
    	writeConcern:1,//写入策略，默认为1即要求确认写操作，0是不要求
    	ordered:true //是否按顺序写入，默认是true
    }

db.users.insertMany([
	{name:'John', age:23},
	{name:'Rebecca', age:64}
]);

db.users.insert([
	{name:'Wonderful', age:32, birthday:'2010-12-31 21:23:21'},
	{name:'Dave', age:22, birthday:'2010-03-12 11:27:11'}
]);

-- 返回结果
BulkWriteResult({
        "writeErrors" : [ ],
        "writeConcernErrors" : [ ],
        "nInserted" : 2,
        "nUpserted" : 0,
        "nMatched" : 0,
        "nModified" : 0,
        "nRemoved" : 0,
        "upserted" : [ ]
})

脚本方式

for(let i=0; i<10; i++){
	db.users.insert({_id:i,name:'Chris_'+i,age:32+i});
}

在mongodb中每个文档都会有一个_id 作为文档的唯一标识，_id默认会自动生成，如果手动指定将使用手动指定的_id值。

查询

1. 查询所有

   db.集合名称.find();

2. 条件查询

   db.集合名称.find(query, projection).pretty();
   

   query: 可选，指定的查询条件

   projection：可选

   pretty()：对超过一定长度的文档进行格式化显示

关系运算符

操作	格式	例子	类比SQL
等于	{key:value}	db.users.find({name:'chris'}).pretty();	where name='chris'
小于	{key:{$lt:value}}	db.users.find({age:{$lt:23}}).pretty();	where age<23
小于等于	{key:{$lte:value}}	db.users.find({age:{$lte:23}}).pretty();	where age<=23
大于	{key:{$gt:value}}	db.users.find({age:{$gt:23}}).pretty();	where age>23
大于等于	{key:{$gte:value}}	db.users.find({age:{$gte:23}}).pretty();	where age>=23
不等于	{key:{$ne:value}}	db.users.find({age:{$ne:23}}).pretty();	where age!=23

逻辑运算符

1. AND

   db.user.find({key1:value1,key2:value2...}).pretty()

db.users.find({name:'Chris', age:33}) --查询 name=Chris 并且 age=33 的文档
db.users.find({age:12, age:{$gt:33}}) --查询 age=12 并且 age>=33 的文档,相同字段出现多次时会以最后一次出现为准

2. OR

   db.users.find({ $or:[ {key1:value1},{key2:value2}... ] });

   --查询 name=John 或者age>33 的文档
   db.users.find({
    $or:[
    	{name:'John'},{age:{$gt:33}}
    ]
   });
   
   --结果
   { "_id" : ObjectId("638df6d54d72a1b3fad46b35"), "name" : "John", "age" : 23 }
   { "_id" : ObjectId("638df6d54d72a1b3fad46b36"), "name" : "Rebecca", "age" : 64 }
   { "_id" : ObjectId("638df6fb4d72a1b3fad46b37"), "name" : "John", "age" : 23 }
   { "_id" : ObjectId("638df6fb4d72a1b3fad46b38"), "name" : "Rebecca", "age" : 64 }
   { "_id" : 9, "name" : "Chris_9", "age" : 41 }
   { "_id" : ObjectId("638e007512b0b293386f7153"), "age" : 45 }
   

3. AND 和 OR联合

   db.users.find({key1:value, $or:[ {key1:value1},{key2:value2}... ] });

   --查询 age>33 的并且名字是 John或者Rebecca 的文档
   db.users.find({
    {age:{$gt:33},
    $or:[
    	{name:'John'},{name:'Rebecca'}
    ]
   });
   
   

in

> db.users.find({name:{$in:['John','Rebecca']}})
{ "_id" : ObjectId("638df6d54d72a1b3fad46b35"), "name" : "John", "age" : 31 }
{ "_id" : ObjectId("638df6d54d72a1b3fad46b36"), "name" : "Rebecca", "age" : 42 }
{ "_id" : ObjectId("638df6fb4d72a1b3fad46b37"), "name" : "John", "age" : 23 }
{ "_id" : ObjectId("638df6fb4d72a1b3fad46b38"), "name" : "Rebecca", "age" : 64 }

数组中的查询

--测试数据
db.users.insert([{ name : "Ethan", age : 33, birthday : "2020-03-12 11:27:11", likes : [ "read", "play toy", "running"]},
name : "Dave", age : 23, birthday : "2010-03-12 11:27:11", likes : [ "read", "girl", "running" ]]);

--查询likes字段有running的文档
db.users.find({likes:"running"})

{ "_id" : ObjectId("638df7174d72a1b3fad46b3a"), "name" : "Dave", "age" : 23, "birthday" : "2010-03-12 11:27:11", "likes" : [ "read", "girl", "running" ] }
{ "_id" : ObjectId("639d9d49b5512c2b26224951"), "name" : "Ethan", "age" : 33, "birthday" : "2020-03-12 11:27:11", "likes" : [ "read", "play toy", "running" ] }

--查询likes字段只有read和running的文档
db.users.find({likes:["read","running"]})

--查询likes字段长度为3的文档
db.users.find({likes:{$size:3}})
{ "_id" : ObjectId("638df7174d72a1b3fad46b3a"), "name" : "Dave", "age" : 23, "birthday" : "2010-03-12 11:27:11", "likes" : [ "read", "girl", "running" ] }
{ "_id" : ObjectId("639d9d49b5512c2b26224951"), "name" : "Ethan", "age" : 33, "birthday" : "2020-03-12 11:27:11", "likes" : [ "read", "play toy", "running" ] }

模糊查询

在mongodb中的模糊查询是通过正则表达式来实现的

--查询名字中包含Chris的文档
db.users.find({name:/Chris/})
--查询名字以Chris开头的文档
db.users.find({name:/^Chris/})
--查询爱好字段中有toy的文档
db.users.find({likes:/toy/})
{ "_id" : ObjectId("639d9d49b5512c2b26224951"), "name" : "Ethan", "age" : 33, "birthday" : "2020-03-12 11:27:11", "likes" : [ "read", "play toy", "running" ] }

排序

1 ： 升序， -1 ： 降序

--按名字降序，如果名字相同则按年龄升序排列
db.users.find().sort({name:-1,age:1})

{ "_id" : ObjectId("638df6d54d72a1b3fad46b36"), "name" : "Rebecca", "age" : 42 }
{ "_id" : ObjectId("638df6fb4d72a1b3fad46b38"), "name" : "Rebecca", "age" : 64 }
{ "_id" : ObjectId("638df6fb4d72a1b3fad46b37"), "name" : "John", "age" : 23 }
{ "_id" : ObjectId("638df6d54d72a1b3fad46b35"), "name" : "John", "age" : 31 }
{ "_id" : ObjectId("639d9d49b5512c2b26224951"), "name" : "Ethan", "age" : 33, "birthday" : "2020-03-12 11:27:11", "likes" : [ "read", "play toy", "running" ] }
{ "_id" : ObjectId("638df7174d72a1b3fad46b3a"), "name" : "Dave", "age" : 23, "birthday" : "2010-03-12 11:27:11", "likes" : [ "read", "girl", "running" ] }
{ "_id" : 9, "name" : "Chris_9", "age" : 41 }
{ "_id" : 8, "name" : "Chris_8", "age" : 40 }
{ "_id" : 7, "name" : "Chris_7", "age" : 39 }
{ "_id" : 6, "name" : "Chris_6", "age" : 38 }
{ "_id" : 5, "name" : "Chris_5", "age" : 37 }
{ "_id" : 4, "name" : "Chris_4", "age" : 36 }
{ "_id" : 3, "name" : "Chris_3", "age" : 35 }
{ "_id" : 2, "name" : "Chris_2", "age" : 34 }
{ "_id" : 1, "name" : "Chris_1", "age" : 33 }
{ "_id" : 0, "name" : "Chris_0", "age" : 31 }

分页查询

类似于sql中的 limit start, rows

start 从 0 开始 :

算法：（页数 -1）x 显示条数

db.users.find().sort({name:-1,age:1}).skip(start).limit(rows);

-- 第1页
db.users.find().sort({name:-1,age:1}).skip(0).limit(2);
-- 第2页
db.users.find().sort({name:-1,age:1}).skip(2).limit(2);
-- 第3页
db.users.find().sort({name:-1,age:1}).skip(4).limit(2);
-- 第4页
db.users.find().sort({name:-1,age:1}).skip(6).limit(2);

总条数

类似于 select count(*) from T where name='Rebecca'

db.users.count()
db.users.find({name:'Rebecca').count();

去重

db.users.distinct('age')
[ 23, 31, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 45, 64 ]

返回指定字段

1: 返回该字段

0:不返回该字段

注意 1 和 0 不能同时使用

--默认返回所有字段
> db.users.find({},{});

--查询结果只返回name字段， 注意 _id是默认都返回的，
> db.users.find({},{name:1});

{ "_id" : ObjectId("638df6d54d72a1b3fad46b35"), "name" : "John" }
{ "_id" : ObjectId("638df6d54d72a1b3fad46b36"), "name" : "Rebecca" }
{ "_id" : ObjectId("638df6fb4d72a1b3fad46b37"), "name" : "John" }
{ "_id" : ObjectId("638df6fb4d72a1b3fad46b38"), "name" : "Rebecca" }
{ "_id" : ObjectId("638df7174d72a1b3fad46b39") }
{ "_id" : ObjectId("638df7174d72a1b3fad46b3a"), "name" : "Dave" }
{ "_id" : 0, "name" : "Chris_0" }
{ "_id" : 1, "name" : "Chris_1" }
{ "_id" : 2, "name" : "Chris_2" }
{ "_id" : 3, "name" : "Chris_3" }
{ "_id" : 4, "name" : "Chris_4" }
{ "_id" : 5, "name" : "Chris_5" }
{ "_id" : 6, "name" : "Chris_6" }
{ "_id" : 7, "name" : "Chris_7" }
{ "_id" : 8, "name" : "Chris_8" }
{ "_id" : 9, "name" : "Chris_9" }
{ "_id" : ObjectId("638e007512b0b293386f7153") }
{ "_id" : ObjectId("639d9d49b5512c2b26224951"), "name" : "Ethan" }

--查询时除过_id字段外，其它字段的0和1不能同时使用
> db.users.find({},{_id:1,age:0})
{ "_id" : ObjectId("638df6d54d72a1b3fad46b35"), "name" : "John" }
{ "_id" : ObjectId("638df6d54d72a1b3fad46b36"), "name" : "Rebecca" }
> db.users.find({},{_id:1,age:1})
{ "_id" : ObjectId("638df6d54d72a1b3fad46b35"), "age" : 31 }
{ "_id" : ObjectId("638df6d54d72a1b3fad46b36"), "age" : 42 }
> db.users.find({},{name:1,age:0})
Error: error: {
        "ok" : 0,
        "errmsg" : "Cannot do exclusion on field age in inclusion projection",
        "code" : 31254,
        "codeName" : "Location31254"
}

$type

$type 操作符是基于Bson类型来检索集合中配置的数据类型并返回结果

当文档中同一个字段的类型不同时可以用$type进行过滤

https://www.mongodb.com/docs/v5.0/reference/operator/query/type/#mongodb-query-op.-type

Bson type

https://www.mongodb.com/docs/v5.0/reference/bson-types/

Mongodb中的数据类型如下

Type	Number	Alias	Notes
Double	1	"double"	mongodb中数字默认都是double类型
String	2	"string"
Object	3	"object"
Array	4	"array"
Binary data	5	"binData"
Undefined	6	"undefined"	Deprecated.
ObjectId	7	"objectId"
Boolean	8	"bool"
Date	9	"date"
Null	10	"null"
Regular Expression	11	"regex"
DBPointer	12	"dbPointer"	Deprecated.
JavaScript	13	"javascript"
Symbol	14	"symbol"	Deprecated.
JavaScript code with scope	15	"javascriptWithScope"	Deprecated in MongoDB 4.4.
32-bit integer	16	"int"
Timestamp	17	"timestamp"
64-bit integer	18	"long"
Decimal128	19	"decimal"
Min key	-1	"minKey"
Max key	127	"maxKey"

查询数据的具体的Bson type类型

Example	Results
{ $type: "a" }	"string"
{ $type: /a/ }	"regex"
{ $type: 1 }	"double"
{ $type: NumberLong(627) }	"long"
{ $type: { x: 1 } }	"object"
{ $type: [ [ 1, 2, 3 ] ] }	"array"

--查询age类型为string的数据
> db.users.find({age:{$type:2}})
> db.users.find({age:{$type:'string'}})

{ "_id" : ObjectId("639d9d49b5512c2b26224951"), "name" : "Ethan", "age" : "3", "birthday" : "2020-03-12 11:27:11", "likes" : [ "read", "play toy", "running" ] }

--查询age类型为double的数据
> db.users.find({age:{$type:1}})
> db.users.find({age:{$type:'double'}})
{ "_id" : ObjectId("638df6d54d72a1b3fad46b35"), "name" : "John", "age" : 31 }
{ "_id" : ObjectId("638df6d54d72a1b3fad46b36"), "name" : "Rebecca", "age" : 42 }
{ "_id" : ObjectId("638df6fb4d72a1b3fad46b37"), "name" : "John", "age" : 23 }
{ "_id" : ObjectId("638df6fb4d72a1b3fad46b38"), "name" : "Rebecca", "age" : 64 }
{ "_id" : ObjectId("638df7174d72a1b3fad46b39"), "age" : 31 }
{ "_id" : ObjectId("638df7174d72a1b3fad46b3a"), "name" : "Dave", "age" : 23, "birthday" : "2010-03-12 11:27:11", "likes" : [ "read", "girl", "running" ] }
{ "_id" : 0, "name" : "Chris_0", "age" : 31 }
{ "_id" : 1, "name" : "Chris_1", "age" : 33 }
{ "_id" : 2, "name" : "Chris_2", "age" : 34 }
{ "_id" : 3, "name" : "Chris_3", "age" : 35 }
{ "_id" : 4, "name" : "Chris_4", "age" : 36 }
{ "_id" : 5, "name" : "Chris_5", "age" : 37 }
{ "_id" : 6, "name" : "Chris_6", "age" : 38 }
{ "_id" : 7, "name" : "Chris_7", "age" : 39 }
{ "_id" : 8, "name" : "Chris_8", "age" : 40 }
{ "_id" : 9, "name" : "Chris_9", "age" : 41 }
{ "_id" : ObjectId("638e007512b0b293386f7153"), "age" : 45 }

删除

db.集合名称.remove(
	<query>,
	{
		justOne:<boolean>,
		writeConcern:<document>
	}
)

query： 可选，删除文档的条件

justOne： 可选，如果设置成true或1，则只删除一个文档，如果不设置或使用默认值false，则删除所有匹配条件的文档。

writeConcern：可选，抛出异常的级别

db.users.remove({}) --删除所有文档
db.users.remove({name:'Chris'}) --删除 name=chris 的文档

> db.users.find()
{ "_id" : ObjectId("638c28e34ce7551b9100bb94"), "name" : "chris" }

db.users.remove({_id:ObjectId("638c28e34ce7551b9100bb94")});--删除自动生成的_id是638c28e34ce7551b9100bb94的文档

更新

db.集合名称.update(
	<query>,
	<update>,
	{
		upsert:<boolean>,
		multi:<boolean>,
		writeConcern:<document>
	}
)

query: 更新文档的查询条件，类型sql update中where后面的条件

update: update的对象和一些更新的操作符，如(,inc...)等，可以理解为sql update 中set中的内容

upsert: 可选，如查更新的文档不存在则插入一个，默认为false

multi: 可选，默认是false，只更新找到的第一条记录，如果设置成true则更新按条件查询出来的全部记录

writeConcern：可选，抛出异常的级别

--会先将 age=32 的删除掉，再插入一条 age=31 的新记录
db.users.update({age:32},{age:31}); 

--如果要保存原来的记录需要加 $set, 更新的时候也可以新增字段
db.users.update({age:32},{$set:{age:31}}); 
db.users.update({name:'John'},{$set:{age:41}});

--更新的时候也可以新增字段
db.users.update({age:22},{$set:{age:23, likes:['read','girl','running']}}); 
--结果 
{ "_id" : ObjectId("638df7174d72a1b3fad46b3a"), "name" : "Dave", "age" : 23, "birthday" : "2010-03-12 11:27:11", "likes" : [ "read", "girl", "running" ] }

--将 age=32 的所有记录的age更新为45,如果没有配置到的记录则插入一条新的记录
db.users.update({age:32},{$set:{age:45}},{multi:true,upsert:true}); 
--结果
WriteResult({
        "nMatched" : 0,
        "nUpserted" : 1,
        "nModified" : 0,
        "_id" : ObjectId("638e007512b0b293386f7153")
})

> db.users.find()
{ "_id" : ObjectId("638e007512b0b293386f7153"), "age" : 45 }

索引

https://www.mongodb.com/docs/v5.0/indexes/

索引是一种特殊的数据结构，存储在一个易于遍历读取的数据集合中，是对数据库中一列或多列值进行排序的一种结构。

如果没有索引，mongodb在读取数据时需要扫描集合中的每个文档，并选取那些符合查询条件的记录，这种扫描全集合的查询效率是非常低的，特别是在处理大量数据时。

mongodb在集合层面上定义了索引，并支持对mongodb集合中的任何字段或文档的子字段进行索引。

默认_id索引： 在创建集合时，mongodb会自动在_id字段上创建唯一索引. _id字段防止写入两个· _id 一样的文档，并且_id上的唯一索引是不能删除的

原理

创建索引

--key值为你要创建索引的字段， 1:指定按升序创建索引，-1:指定按降序来创建索引
db.users.createIndex(keys, options)

--在字段name和age字段上创建索引，在name字段升序创建索引，当age字段相同时，再在age字段按降序创建索引
db.users.createIndex({name:1, age:-1})

--创建索引时,指定索引名称为 name_age_inx，且为唯一索引
> db.users.createIndex({name:1, age:-1},{name:'name_age_inx', unique:true});
{
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "createdCollectionAutomatically" : false,
        "ok" : 1
}
> db.users.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_"
        },
        {
                "v" : 2,
                "key" : {
                        "name" : 1,
                        "age" : -1
                },
                "name" : "name_age_inx",
                "unique" : true
        }
]

--创建索引时,指定索引名称为，且指定过期时间为10秒
> db.users.createIndex({name:1},{expireAfterSeconds:10})
{
        "numIndexesBefore" : 2,
        "numIndexesAfter" : 3,
        "createdCollectionAutomatically" : false,
        "ok" : 1
}

> db.users.getIndexes()
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_"
        },
        {
                "v" : 2,
                "key" : {
                        "name" : 1,
                        "age" : -1
                },
                "name" : "name_age_inx",
                "unique" : true
        },
        {
                "v" : 2,
                "key" : {
                        "name" : 1
                },
                "name" : "name_1",
                "expireAfterSeconds" : 10
        }
]

Parameter	type	Desc
background	Booelean	【可选】默认为false, 索引创建时会阻塞其它数据库操作，可以指定后台创建。
unique	Boolean	【可选】默认为false, 是否创建唯一索引
name	String	【可选】索引名称, 如果不指定，默认按照字段名称+排序顺序生成一个名称
expireAftertSeconds	Integer	【可选】索引过期时间, 单位为秒，只能指定在单字段索引的过期时间
v	index version	索引的版本号，默认取决于mongodb创建索引时运行的版本

查询集合中的索引

--查询一个集合里面的索引
> db.users.getIndexes()
[ { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id_" } ]

--查询集合索引大小
db.users.totalIndexSize()
36864 --字节

删除集合中的索引

--删除集合中所有的索引
db.users.dropIndexes()

--删除集合中名称为'name_index'的索引
db.users.dropIndex('name_index')

复合索引

复合索引生效和mysql一样，适用左包含原则，

https://docs.mongodb.com/manual/tutorial/sort-results-with-indexes/#std-lable-sort-on-multiple-fields

if the sort keys correspond to the index keys or an index prefix, MongoDB can use the index to sort the query results. A prefix of a compound index is a subset that consists of one or more keys at the start of the index key pattern.

For example, create a compound index on the data collection:

db.data.createIndex( { a:1, b: 1, c: 1, d: 1 } )

Then, the following are prefixes for that index:

{ a: 1 }
{ a: 1, b: 1 }
{ a: 1, b: 1, c: 1 }
{ a: 1, b: 1, c: 1, d: 1 }

b a c d 也是可以走复合索引的同，

如果检索的字段包含复合索引的全部字段但是顺序不同，引擎会自动优化来使用复合索引

mongodb中排序也是可以使用索引的

The following query and sort operations use the index prefixes to sort the results. These operations do not need to sort the result set in memory.

Example	Index Prefix
db.data.find().sort( { a: 1 } )	{ a: 1 }
db.data.find().sort( { a: -1 } )	{ a: 1 }
db.data.find().sort( { a: 1, b: 1 } )	{ a: 1, b: 1 }
db.data.find().sort( { a: -1, b: -1 } )	{ a: 1, b: 1 }
db.data.find().sort( { a: 1, b: 1, c: 1 } )	{ a: 1, b: 1, c: 1 }
db.data.find( { a: { $gt: 4 } } ).sort( { a: 1, b: 1 } )	{ a: 1, b: 1 }

聚合查询

mongodb中的聚合主要用于处理数据，如统计平均值，求和等，并返回计算后的数据结果，类似于mysql中的count()

1

2

3

4

package com.chris.cloud.importer.bean;

public interface ServiceInterface {
    void test();
}

package com.chris.cloud.importer.bean.impl;
import com.chris.cloud.importer.bean.ServiceInterface;

public class ServiceA implements ServiceInterface {
    public ServiceA() {
        System.out.println("new service A");
    }

    @Override
    public void test() {
        System.out.println("ServiceA");
    }
}


package com.chris.cloud.importer.bean.impl;

import com.chris.cloud.importer.bean.ServiceInterface;

public class ServiceB implements ServiceInterface {
    public ServiceB() {
        System.out.println("new service B");
    }

    @Override
    public void test() {
        System.out.println("ServiceB");
    }
}



package com.chris.cloud.importer.bean.impl;

import cn.hutool.json.JSONUtil;
import com.chris.cloud.importer.bean.impl.ServiceB;
import com.chris.cloud.importer.config.ConfigB;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.type.AnnotationMetadata;

@Slf4j
@SuppressWarnings({"NullableProblems"})
public class ServiceImportSelector implements ImportSelector {
    /**
     * 通过AnnotationMetadata里面的属性，动态加载类。AnnotationMetadata是Import注解所在的类属性（如果所在类是注解类，则延伸至应用这个注解类的非注解类为止）
     *
     * @param importingClassMetadata com.chris.cloud.importer.config.ConfigA
     * @return 返回要加载的@Configuation或者具体Bean类的全限定名的String数组
     */
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        //可以是@Configuration注解修饰的类，也可以是具体的Bean类的全限定名称
        String[] beanClzNames = new String[]{ConfigB.class.getName()/*, ServiceB.class.getName()*/};
        log.info("beanClzNames:{}", JSONUtil.toJsonStr(beanClzNames));

        return beanClzNames;
    }
}


package com.chris.cloud.importer.bean.impl;

import com.chris.cloud.importer.bean.EnableImportService;
import com.chris.cloud.importer.utils.ImportUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.ImportSelector;
import org.springframework.core.annotation.MergedAnnotations;
import org.springframework.core.type.AnnotationMetadata;

import java.util.Map;
import java.util.Set;

@Slf4j
@SuppressWarnings({"NullableProblems"})
public class ServiceImportSelector2 implements ImportSelector {
    /**
     * 通过AnnotationMetadata里面的属性，动态加载类。AnnotationMetadata是Import注解所在的类属性（如果所在类是注解类，则延伸至应用这个注解类的非注解类为止）
     *
     * @param importingClassMetadata com.chris.cloud.importer.config.ConfigA
     * @return 返回要加载的@Configuation或者具体Bean类的全限定名的String数组
     */
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        MergedAnnotations annotations = importingClassMetadata.getAnnotations();
        Set<String> annotationTypes = importingClassMetadata.getAnnotationTypes();
        Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(EnableImportService.class.getName());
        Map<String, Object> annoMap = importingClassMetadata.getAnnotationAttributes(EnableImportService.class.getName(), true);

        return ImportUtil.getClzNames(annoMap);
    }
}


package com.chris.cloud.importer.bean;

import com.chris.cloud.importer.bean.impl.ServiceImportSelector2;
import org.springframework.context.annotation.Import;

import java.lang.annotation.*;

@Retention(RetentionPolicy.RUNTIME)
@Documented
@Target(ElementType.TYPE)
@Import(ServiceImportSelector2.class)
@SuppressWarnings({"rawtypes"})
public @interface EnableImportService {
    Class[] clz_names();
}


public class User1 {
    private String name;
}

public class User2 {
    private String name;
}




package com.chris.cloud.importer.config;

import com.chris.cloud.importer.bean.EnableImportService;
import com.chris.cloud.importer.bean.ServiceInterface;
import com.chris.cloud.importer.bean.impl.ServiceA;
import com.chris.cloud.importer.bean.impl.ServiceB;
import com.chris.cloud.importer.bean.impl.ServiceImportSelector;
import com.chris.cloud.importer.bean.impl.User1;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Import(ConfigB.class)

//Spring 4.2之后，@Import可以直接指定实体类，加载这个类定义到context中, @Import(ServiceB.class)，就会生成ServiceB的Bean到容器上下文中
//@Import(ServiceB.class)

//通过mportSelector实现动态加载，需要返回要加载的@Configuation或者具体Bean类的全限定名的String数组
//@Import(ServiceImportSelector.class)

//@EnableImportService(clz_names = {ConfigB.class})
@Configuration
@Slf4j
public class ConfigA {

    ConfigA() {
        log.info("begin get configA");
    }

    @Bean
    public Object getUser1() {
        log.info("begin get User1");
        return new User1();
    }

    @Bean
    @ConditionalOnMissingBean
    public ServiceInterface getServiceA() {
        log.info("begin get service A");
        return new ServiceA();
    }
}


package com.chris.cloud.importer.config;

import com.chris.cloud.importer.bean.impl.ServiceB;
import com.chris.cloud.importer.bean.ServiceInterface;
import com.chris.cloud.importer.bean.impl.User2;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Slf4j
public class ConfigB {
    ConfigB() {
        log.info("begin get configB");
    }

    @Bean
    public Object getUser2() {
        log.info("begin get User2");
        return new User2();
    }

    @Bean
    @ConditionalOnMissingBean
    public ServiceInterface getServiceB() {
        log.info("begin get service B");
        return new ServiceB();
    }
}


package com.chris.cloud;

@SpringBootTest(classes = Cloud2022Application.class)
@RunWith(SpringJUnit4ClassRunner.class)
@Slf4j
public class ImportTest implements ApplicationContextAware {

    private ApplicationContext applicationContext;


    @Test
    public void test2() {
//        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(ConfigA.class);
        ServiceInterface bean = this.applicationContext.getBean(ServiceInterface.class);
        bean.test();
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
}

1.常见注解

1.1 @Autowired

按 byType 自动注入
@Autowired默认按类型装配（这个注解是属于spring的），默认情况下必须要求依赖对象必须存在，如果要允许null值，可以设置它的required属性为false，
如：@Autowired(required=false)，如果我们想使用名称装配可以结合@Qualifier注解进行使用

@Autowired()
@Qualifier("baseDao")
private BaseDao baseDao;

1.1.@Resource

默认按 byName 自动注入
默认按照名称进行装配，名称可以通过name属性进行指定，如果没有指定name属性，当注解写在字段上时，默认取字段名进行安装名称查找，如果注解写在setter方法上默认取属性名进行装配

@Resource(name="baseDao")
private BaseDao baseDao;

@Resource 装配顺序

• 1. 如果同时指定了name和type，则从Spring上下文中找到唯一匹配的bean进行装配，找不到则抛出异常
• 2. 如果指定了name，则从上下文中查找名称（id）匹配的bean进行装配，找不到，再根据类型匹配的唯一bean进行装配，找不到或者找到多个，都会抛出异常则抛出异常
• 3. 如果指定了type，则从上下文中找到类型匹配的唯一bean进行装配，找不到会抛出异常，找到多个，会根据默认取字段名进行名称匹配，匹配不到则报错。
• 4. 如果既没有指定name，又没有指定type，则自动按照byName方式进行装配；如果没有匹配，则回退为一个原始类型进行匹配，如果匹配则自动装配；

1.3 @Qualifier注解

@Autowired是根据类型进行自动装配的。

1. 如果当Spring上下文中存在不止一个UserDao类型的bean时，就会抛出BeanCreationException异常;

@Autowired  
@Qualifier("userServiceImpl")  
public IUserService userService;

@Autowired   
public void setUserDao(@Qualifier("userDao") UserDao userDao) {   
    this.userDao = userDao;   
}  

这样Spring会找到id为userServiceImpl和userDao的bean进行装配。

1. 如果Spring上下文中不存在UserDao类型的bean，也会抛出BeanCreationException异常。

@Autowired(required = false)   
public IUserService userService  

1.4 定义Bean

1.4.1 @Controller

定义控制层Bean,如Action

@Controller
@Controller("Bean的名称")

1.4.1.@Service

定义业务层Bean

@Service          
@Service("Bean的名称")

1.4.3 @Repository

定义DAO层Bean

@Repository   
@Repository("Bean的名称")

1.4.4 @Component

定义Bean, 不好归类时使用.

1.4.5 @Configuration

使用注解@Configuration，告诉Spring容器这是一个配置类.
@Bean：给容器中添加组件，以方法名作为组件的id。返回类型为组件类型，返回的值，就是组件在容器中的实例

@Configuration
public class ConfigProxyBeanMethods {

    @Bean
    public User getUser01() {
        return new User();
    }

    @Bean
    public Pet getPet01() {
        return new Pet();
    }

    /*@Bean("oh baby")
    public Pet getPet01() {
        return new Pet();
    }*/
}
/**
     * 2022-12-14 22:18:00.558  INFO 5604 --- [           main] com.chris.cloud.ConfigProxyTest          : bean name :getUser01
     * 2022-12-14 22:18:00.558  INFO 5604 --- [           main] com.chris.cloud.ConfigProxyTest          : bean name :getPet01
     * <p>
     * <p>
     * 2022-12-14 22:20:24.551  INFO 11480 --- [           main] com.chris.cloud.ConfigProxyTest          : bean name :getUser01
     * 2022-12-14 22:20:24.551  INFO 11480 --- [           main] com.chris.cloud.ConfigProxyTest          : bean name :oh baby
     */
    @Test
    public void test1() {
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (String beanDefinitionName : beanDefinitionNames) {
            log.info("bean name :{}", beanDefinitionName);
        }
    }

proxyBeanMethods = false

@Configuration(proxyBeanMethods = false)
public class ConfigProxyBeanMethods {

    @Bean
    public User getUser01() {
        return new User();
    }

    @Bean
    public Pet getPet01() {
        return new Pet();
    }

    /*@Bean("oh baby")
    public Pet getPet01() {
        return new Pet();
    }*/
}

/**
 * proxyBeanMethods，默认为true
 * 容器中注册的组件默认是单实例的
 * 在向容器中注册组件时，会在容器中查找有没有该组件。如果有，则取该组件用于保证单实例，如果没有再注册一个新的组件。
 * 2022-12-14 23:06:00.966  INFO 17044 --- [           main] com.chris.cloud.ConfigProxyTest          : user01.equals(user02): true
 * 2022-12-14 23:06:00.967  INFO 17044 --- [           main] com.chris.cloud.ConfigProxyTest          : user01 == user02 : true
 * 2022-12-14 23:06:00.967  INFO 17044 --- [           main] com.chris.cloud.ConfigProxyTest          : getUser01 == user01: true
 * <p>
 * proxyBeanMethods 改为false
 *
 * 2022-12-14 23:05:21.110  INFO 4244 --- [           main] com.chris.cloud.ConfigProxyTest          : user01.equals(user02): true
 * 2022-12-14 23:05:21.110  INFO 4244 --- [           main] com.chris.cloud.ConfigProxyTest          : user01 == user02 : true
 * 2022-12-14 23:05:21.110  INFO 4244 --- [           main] com.chris.cloud.ConfigProxyTest          : getUser01 == user01: false
 */
@Test
public void test2() {
    ConfigProxyBeanMethods bean = applicationContext.getBean(ConfigProxyBeanMethods.class);
    User getUser01 = bean.getUser01();

    User user01 = applicationContext.getBean("getUser01", User.class);
    User user02 = applicationContext.getBean("getUser01", User.class);

    log.info("user01.equals(user02): {}", user01.equals(user02));
    log.info("user01 == user02 : {}", user01 == user02);
    log.info("getUser01 == user01: {}", getUser01 == user01);

}

1.5 @Scope("prototype")

定义Bean的作用域和生命过程

@Scope("prototype")
值有:singleton,prototype,request,session,globalSession

1.6 @PostConstruct

相当于init-method , 使用在方法上，当Bean初始化时执行。

1.7 @PreDestroy

相当于destory-method，使用在方法上，当Bean销毁时执行。

2. @ConfigurationProperties

告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；
prefix = "xxx"：配置文件中哪个下面的所有属性进行一一映射
只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；

@ConfigurationProperties(prefix = "xxx")默认从全局配置文件中获取值；

@Component
@ConfigurationProperties(prefix = "async.executor.thread")
@Data
public class ThreadPoolConfigBean {
    private int corePoolSize;
    private int maxPoolSize;
    private int queueCapacity;
    private String namePrefix;
}

3. @EnableConfigurationProperties

@EnableConfigurationProperties 注解的作用是：使使用 @ConfigurationProperties 注解的类生效.

如果一个配置类只配置@ConfigurationProperties 注解，而没有使用@Component，那么在IOC容器中是获取不到properties 配置文件转化的bean。说白了 @EnableConfigurationProperties 相当于把使用 @ConfigurationProperties 的类进行了一次注入。

@Configuration
@EnableConfigurationProperties(ThreadPoolConfigBean.class)
public class ExecutorConfig {
    @Resource
    private ThreadPoolConfigBean configBean;

4. @ConfigurationPropertiesScan

可以用来替换@EnableConfigurationProperties，配置在主启动类上对项目中的属性配
置类统一扫描后生成bean放到容器中

@SpringBootApplication(exclude = DruidDataSourceAutoConfigure.class)
@MapperScan("com.chris.mybatisplus.dao.mapper")
@ConfigurationPropertiesScan("com.chris.mybatisplus.config")
@EnableAsync
public class MybatisPlusMain {
    public static void main(String[] args) {
        SpringApplication.run(MybatisPlusMain.class, args);
    }
}

6. @ConfigurationOnXXX

/** 这里加了@ConditionalOnBean注解，就代表如果city存在才实例化people*/ 
@Bean 
@ConditionalOnBean(name = "city")
public People (City city) { //这里如果city实体没有成功注入 这里就会报空指针  
    city.setCityCode(301701); 
    return new People("小小", 3, city); 
}

@Conditional({WindowsCondition.class})
@ConditionalOnBean（仅仅在当前上下文中存在某个对象时，才会实例化一个Bean）
@ConditionalOnClass（某个class位于类路径上，才会实例化一个Bean）
@ConditionalOnExpression（当表达式为true的时候，才会实例化一个Bean）
@ConditionalOnMissingBean（仅仅在当前上下文中不存在某个对象时，才会实例化一个Bean）
@ConditionalOnMissingClass（某个class类路径上不存在的时候，才会实例化一个Bean）
@ConditionalOnNotWebApplication（不是web应用）

当前上下文中不存在TeamTalkService对象时，才会实例化一个TeamTalkService Bean

@Bean
@ConditionalOnMissingBean(TeamTalkService.class)
public TeamTalkService teamTalkService() {    
    return new TeamTalkService(prefix, appId, secret);
}

7. @ConditionalOnProperty

Spring Boot通过@ConditionalOnProperty来控制Configuration是否生效
通过其两个属性name以及havingValue来实现的，其中name用来从application.properties中读取某个属性值。
如果该值为空，则返回false;
如果值不为空，则将该值与havingValue指定的值进行比较，如果一样则返回true;否则返回false。
如果返回值为false，则该configuration不生效；为true则生效。

//控制某个configuration是否生效

@Configuration 
@ConditionalOnProperty(prefix = "filter",name = "loginFilter",havingValue = "true", 
matchIfMissing=false) 
public class FilterConfig { 
// prefix 为配置文件中的前缀, 
// name 为配置的名字 
// havingValue 是与配置的值对比值,当两个值相同返回true,配置类生效. 
// matchIfMissing 缺少该property时是否可以加载。如果为true，没有该property也会正常加载；反之报错

@Bean 
public FilterRegistrationBean getFilterRegistration() { 
      FilterRegistrationBean filterRegistration = new FilterRegistrationBean(new LoginFilter());
      filterRegistration.addUrlPatterns("/*"); 
      return filterRegistration; }
 }

配置文件中的代码

filter.loginFilter=true

1 控制反转IOC

IOC 的核心就是原先创建一个对象，我们需要自己直接通过 new 来创建，而 IOC 就相当于有人帮们创建好了对象，需要使用的时候直接去拿就行

IOC 主要有两种实现方式：
DL（Dependency Lookup）：依赖查找
DI（Dependency Inject）：依赖注入

1.1 依赖查找

DL（Dependency Lookup）

容器帮我们创建好了对象，我们需要使用的时候自己再主动去容器中查找

ApplicationContext applicationContext = new ClassPathXmlApplicationContext("/application-context.xml");
Object bean = applicationContext.getBean("object");

1.2 依赖注入

DI（Dependency Inject）

依赖注入相比较依赖查找又是一种优化，也就是我们不需要自己去查找，只需要告诉容器当前需要注入的对象，容器就会自动将创建好的对象进行注入（赋值）

1.2.1 三种常规注入方式

1. 基于属性注入

@Service
public class UserService {
    @Autowired
    private Wolf1Bean wolf1Bean;//通过属性注入
}

2. 基于 setter 方法

@Service
public class UserService {
    private Wolf3Bean wolf3Bean;
    
    @Autowired  //通过setter方法实现注入
    public void setWolf3Bean(Wolf3Bean wolf3Bean) {
        this.wolf3Bean = wolf3Bean;
    }
}

3. 注入基于构造器注入

@Service
public class UserService {
  private Wolf2Bean wolf2Bean;
    
    @Autowired //通过构造器注入
    public UserService(Wolf2Bean wolf2Bean) {
        this.wolf2Bean = wolf2Bean;
    }
}

1.2.2 接口注入

假如我们想要注入一个接口，而当前接口又有多个实现类，那么这时候就会报错，因为 Spring 无法知道到底应该注入哪一个实现类。

比如我们上面的三个类全部实现同一个接口 IWolf，那么这时候直接使用常规的，不带任何注解元数据的注入方式来注入接口 IWolf。

@Autowired
private IWolf iWolf;

解决思路主要有以下 5 种：

1. 通过配置文件和 @ConditionalOnProperty 注解实现

   配置文件中配置了lonely.wolf=test1

@Component
@ConditionalOnProperty(name = "lonely.wolf",havingValue = "test1")
public class Wolf1Bean implements IWolf{
}

这种配置方式，编译器可能还是会提示有多个 Bean，但是只要我们确保每个实现类的条件不一致，就可以正常使用。

2. 通过其他 @Condition 条件注解

@ConditionalOnBean：当存在某一个 Bean 时，初始化此类到容器。
@ConditionalOnClass：当存在某一个类时，初始化此类的容器。
@ConditionalOnMissingBean：当不存在某一个 Bean 时，初始化此类到容器。
@ConditionalOnMissingClass：当不存在某一个类时，初始化此类到容器。

3. 通过 @Resource 注解动态获取

只会注入 BeanName 为 wolf1Bean 的实现类

@Component
public class InterfaceInject {
    @Resource(name = "wolf1Bean")
    private IWolf iWolf;
}

4. 通过集合注入

可以通过集合的方式一次性注入接口的所有实现类
这两种形式都会将 IWolf 中所有的实现类注入集合中。
如果使用的是 List 集合，那么我们可以取出来再通过 instanceof 关键字来判定类型；
通过 Map 集合注入的话，Spring 会将 Bean 的名称默认类名首字母小写作为key来存储，这样我们就可以在需要的时候动态获取自己想要的实现类。

@Component
public class InterfaceInject {
    @Autowired
    List<IWolf> list;

    @Autowired
    private Map<String,IWolf> map;
}

5. @Primary 注解实现默认注入

在其中某一个实现类上加上@Primary注解来表示当有多个 Bean 满足条件时，优先注入当前带有@Primary注解的 Bean

@Component
@Primary
public class Wolf1Bean implements IWolf{
}

2. 手动获取Bean的方式

2.1.直接注入

@Component
public class InterfaceInject {
    //注入
    @Autowired
    private ApplicationContext applicationContext;

    public Object getBean(){
        //获取bean
        return applicationContext.getBean("wolf2.ean");
    }
}

2.2 通过 ApplicationContextAware 接口获取

通过实现ApplicationContextAware接口来获取ApplicationContext对象，从而获取 Bean。
需要注意的是，实现ApplicationContextAware接口的类也需要加上注解，以便交给 Spring 统一管理（这种方式也是项目中使用比较多的一种方式）

@Component
public class SpringContextUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext = null;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }
    /**
     * 通过名称获取bean
     */
    public static <T> T getBeanByName(String beanName){
        return (T) applicationContext.getBean(beanName);
    }
    /**
     * 通过类型获取bean
     */
    public static <T>T getBeanByType(Class<T> clazz){
        return (T) applicationContext.getBean(clazz);
    }
}

Wolf2Bean wolf2Bean = SpringContextUtil.getBeanByName("wolf2Bean");
Wolf3Bean wolf3Bean = SpringContextUtil.getBeanByType(Wolf3Bean.class);

2.3 通过 ApplicationObjectSupport 和 WebApplicationObjectSupport 获取

这两个对象中，WebApplicationObjectSupport继承了ApplicationObjectSupport，所以并无实质的区别。

@Component
public class SpringUtil extends /*WebApplicationObjectSupport*/ ApplicationObjectSupport {
    private static ApplicationContext applicationContext = null;

    public static <T>T getBean(String beanName){
        return (T) applicationContext.getBean(beanName);
    }

    @PostConstruct
    public void init(){
        applicationContext = super.getApplicationContext();
    }
}

//有了工具类，在方法中就可以直接调用了：
@RestController
@RequestMapping("/hello")
@Qualifier
public class HelloController {
    @GetMapping("/bean3")
    public Object getBean3(){
        Wolf2.ean wolf2.ean = SpringUtil.getBean("wolf2.ean");
        return wolf2.ean.toString();
    }
}

2.4 通过 HttpServletRequest 获取

通过HttpServletRequest对象，再结合 Spring 自身提供的工具类WebApplicationContextUtils也可以获取到ApplicationContext对象，
而HttpServletRequest对象可以主动获取（如下 getBean2 方法），也可以被动获取（如下 getBean2.方法）：

@RestController
@RequestMapping("/hello")
@Qualifier
public class HelloController {

    @GetMapping("/bean2.)
    public Object getBean2.HttpServletRequest request){
        //直接通过方法中的HttpServletRequest对象
        ApplicationContext applicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());
        Wolf2.ean wolf2.ean = (Wolf2.ean)applicationContext.getBean("wolf2.ean");

        return wolf2.ean.toString();
    }

    @GetMapping("/bean2")
    public Object getBean2(){
        //手动获取request对象
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        ApplicationContext applicationContext = WebApplicationContextUtils.getRequiredWebApplicationContext(request.getServletContext());

        Wolf2Bean wolf2Bean = (Wolf2Bean)applicationContext.getBean("wolf2Bean");
        return wolf2Bean.toString();
    }
}

1.查看依赖

mvn dependency:tree

mvn dependency:tree -Dverbose -Dincludes=commons-collections

idea 可以安装 maven helper 插件

2. maven-surefire-plugin

Failed to execute goal org.apache.maven.plugins:maven-surefire-plugin:2.12.4:test

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>3.0.0-M5</version>
    <configuration>
    	<skipTests>true</skipTests>
    </configuration>
</plugin>

3. 添加aliyun镜像

D:\apache-maven-3.6.3\conf\settings.xml

  <mirror> 
      <id>alimaven</id> 
      <name>aliyun maven</name> 
      <url>http://maven.aliyun.com/nexus/content/repositories/central/</url> 
      <mirrorOf>central</mirrorOf> 
    </mirror>

4. spring-boot-maven-plugin

简述

spring-boot-maven-plugin是spring boot提供的maven打包插件。可打直接可运行的jar包或war包。

官网

https://docs.spring.io/spring-boot/docs/2.2.1.RELEASE/maven-plugin/

Goal	Description
spring-boot:build-info	Generate a build-info.properties file based the content of the current MavenProject.
spring-boot:help	Display help information on spring-boot-maven-plugin. Call mvn spring-boot:help -Ddetail=true -Dgoal= to display parameter details.
spring-boot:repackage	Repackages existing JAR and WAR archives so that they can be executed from the command line using java -jar. With layout=NONE can also be used simply to package a JAR with nested dependencies (and no main class, so not executable).
spring-boot:run	Run an executable archive application.
spring-boot:start	Start a spring application. Contrary to the run goal, this does not block and allows other goal to operate on the application. This goal is typically used in integration test scenario where the application is started before a test suite and stopped after.
spring-boot:stop	Stop a spring application that has been started by the "start" goal. Typically invoked once a test suite has completed.

打包：repackage
打包主要使用的是repackage goal，它是spring-boot-starter-parent为插件设置的默认goal。这个goal绑定在maven的 package生命周期上，完整命令为mvn package spring-boot:repackage。在 mvn package 执行打包之后，repackage 再次打包生成可执行的 jar包或war包.

5. 打源码包

<!-- 打源码包 -->
<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-source-plugin</artifactId>
    <version>3.2.1</version>
    <executions>
        <execution>
            <id>attach-sources</id>
            <phase>verify</phase>
            <goals>
                <goal>jar-no-fork</goal>
            </goals>
        </execution>
    </executions>
</plugin>

Maven中的scope主要有以下6种，接下来分别介绍下这几种Scope：

1. compile

不声明scope元素的情况下的 默认值；
compile表示被依赖包需要参与当前项目的编译，包括后续的测试，运行周期也参与其中，是一个比较强的依赖；
打包的时候通常需要包含进去。

2. provided

provided 类型的scope只会在项目的编译，测试阶段起作用；

可以认为在目标容器中已经提供了这个依赖，无需在提供，但是在编写代码或者编译时可能会用到这个依赖；

依赖不会被打入到项目jar包中

说到provided，这里就要说到<dependency>下的子标签<optional> ，如果一个依赖的<optional> 设置为true，则该依赖在打包的时候不会被打进jar包，同时不会通过依赖传递传递到依赖该项目的工程；
例如：x依赖B，B由依赖于A（x->B->A），则A中设置<optional> 为true的依赖不会被传递到x中。

这两者的区别在于：
1、<optional>为true 表示某个依赖可选，该依赖是否使用都不会影响服务运行；
2、provided的<scope>在目标容器中已经提供了这个依赖，无需在提供

3. runtime

runtime 与 compile 比较相似，区别在于runtime 跳过了编译阶段，打包的时候通常需要包含进去。

4. test

在一般的编译和运行时都不需要，它们只有在测试编译和测试运行阶段可用，

不会被打包到项目jar包中，

同时如果项目A依赖于项目B，项目B中的test作用域下的依赖不会被继承。

5. system

表示使用本地系统路径下的jar包，需要和一个systemPath一起使用，如下：

<dependency>
	<groupId>xxxx</groupId>
	<artifactId>xxx</artifactId>
	<systemPath>${basedir}/lib/xxxxx.jar</systemPath>
	<scope>system</scope>
	<version>1.4.12</version>
</dependency>

6. import

import 只能在pom文件的<dependencyManagement>中使用，从而引入其他的pom文件中引入依赖，

如：在Spring boot 项目的POM文件中，我们可以通过在POM文件中继承 Spring-boot-starter-parent来引用Spring boot默认依赖的jar包，如下：

<parent>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.0.1.BUILD-SNAPSHOT</version>
</parent>

但是，通过上面的parent继承的方法，只能继承一个 spring-boot-start-parent。
实际开发中，用户很可能需要继承自己公司的标准parent配置，这个时候可以使用 scope=import 来实现多继承。代码如下：

<dependencyManagement>
     <dependencies>
         <dependency>
             <!-- Import dependency management from Spring Boot -->
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-dependencies</artifactId>
             <version>2.0.1.BUILD-SNAPSHOT</version>
             <type>pom</type>
             <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

通过上面方式，就可以获取spring-boot-dependencies.2.0.1.BUILD-SNAPSHOT.pom文件中dependencyManagement配置的jar包依赖。
如果要继承多个，可以在dependencyManagement中添加，如：

<dependencyManagement>
     <dependencies>
         <!-- Override Spring Data release train provided by Spring Boot -->
         <dependency>
             <groupId>org.springframework.data</groupId>
             <artifactId>spring-data-releasetrain</artifactId>
             <version>Fowler-SR2</version>
             <type>pom</type>
             <scope>import</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.0.1.BUILD-SNAPSHOT</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

1. Cache

package com.chris.guava.cache;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import com.google.common.cache.RemovalListener;
import com.google.common.cache.RemovalNotification;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

public class CacheTest {

    /**
     * 通过CacheBuilder类构建一个缓存对象，CacheBuilder类采用builder设计模式，它的每个方法都返回CacheBuilder本身，直到build方法被调用
     */
    @Test
    public void test1() {
        Cache<String, String> cache = CacheBuilder.newBuilder().build();
        cache.put("word", "Hello Guava Cache");
        System.out.println(cache.getIfPresent("word"));
    }

    /**
     * 设置最大存储
     * Guava Cache可以在构建缓存对象时指定缓存所能够存储的最大记录数量。
     * 当Cache中的记录数量达到最大值后，再调用put方法向其中添加对象，Guava会先从当前缓存的对象记录中选择一条删除掉，腾出空间后，再将新的对象存储到Cache中。
     * 第一个值：null
     * 第二个值：value2
     * 第三个值：value3
     */
    @Test
    public void test2() {
        Cache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(2)
                .build();
        cache.put("key1", "value1");
        cache.put("key2", "value2");
        cache.put("key3", "value3");
        System.out.println("第一个值：" + cache.getIfPresent("key1"));
        System.out.println("第二个值：" + cache.getIfPresent("key2"));
        System.out.println("第三个值：" + cache.getIfPresent("key3"));
    }

    /**
     * 设置过期时间
     * <p>
     * 可以通过CacheBuilder类的expireAfterAccess和expireAfterWrite两个方法为缓存中的对象指定过期时间
     * 使用CacheBuilder构建的缓存不会“自动”执行清理和逐出值，也不会在值到期后立即执行或逐出任何类型。
     * 相反，它在写入操作期间执行少量维护，或者在写入很少的情况下偶尔执行读取操作。
     * 其中，expireAfterWrite方法指定对象被写入到缓存后多久过期，expireAfterAccess方法指定对象多久没有被访问后过期。
     * <p>
     * 第1次取到key1的值为：value1
     * 第2次取到key1的值为：value1
     * 第3次取到key1的值为：value1
     * 第4次取到key1的值为：null
     * 第5次取到key1的值为：null
     */
    @Test
    public void test3() throws InterruptedException {
        Cache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(2)
                .expireAfterWrite(3, TimeUnit.SECONDS)
                .build();
        cache.put("key1", "value1");
        int time = 1;
        while (time <= 5) {
            System.out.println("第" + time++ + "次取到key1的值为：" + cache.getIfPresent("key1"));
            Thread.sleep(1000);
        }
    }

    /**
     * 通过CacheBuilder的expireAfterAccess方法，指定如果Cache中存储的对象超过3秒没有被访问，就会过期。
     * while中的代码每sleep一段时间，就会访问一次Cache中存储的对象key1；每次访问key1之后，下次sleep的时间会加长一秒。
     * 也可以同时用expireAfterAccess和expireAfterWrite方法指定过期时间，这时只要对象满足两者中的一个条件，就会被自动过期删除。
     * <p>
     * 睡眠1秒后取到key1的值为：value1
     * 睡眠2秒后取到key1的值为：value1
     * 睡眠3秒后取到key1的值为：null
     * 睡眠4秒后取到key1的值为：null
     * 睡眠5秒后取到key1的值为：null
     */
    @Test
    public void test4() throws InterruptedException {
        Cache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(2)
                .expireAfterAccess(3, TimeUnit.SECONDS)
                .build();
        cache.put("key1", "value1");
        int time = 1;
        while (time <= 5) {
            Thread.sleep(time * 1000L);
            System.out.println("睡眠" + time++ + "秒后取到key1的值为：" + cache.getIfPresent("key1"));
        }
    }


    /**
     * 显示清除缓存
     * <p>
     * 调用Cache的invalidateAll或invalidate方法，可以显示删除Cache中的记录。
     * invalidate方法一次只能删除Cache中一个记录，接收的参数是要删除记录的key。
     * invalidateAll方法可以批量删除Cache中的记录；当没有传任何参数时，invalidateAll方法将清除Cache中的全部记录。
     * <p>
     * cache size:4
     * invalidate key1 cache size:3
     * invalidate key2 key3 cache size:1
     * invalidate all cache size:0
     * null
     * null
     * null
     */
    @Test
    public void test5() {
        Cache<String, String> cache = CacheBuilder.newBuilder().build();
        cache.put("key1", "value1");
        cache.put("key2", "value2");
        cache.put("key3", "value3");
        cache.put("key4", "value4");
        System.out.println("cache size:" + cache.size());
        cache.invalidate("key1");
        System.out.println("invalidate key1 cache size:" + cache.size());
        List<String> list = new ArrayList<>();
        list.add("key2");
        list.add("key3");
        cache.invalidateAll(list);  //批量清除list中全部key对应的记录
        System.out.println("invalidate key2 key3 cache size:" + cache.size());
        cache.invalidateAll();
        System.out.println("invalidate all cache size:" + cache.size());
        System.out.println(cache.getIfPresent("key1"));
        System.out.println(cache.getIfPresent("key2"));
        System.out.println(cache.getIfPresent("key3"));
    }

    /**
     * 移除动作监听器
     * <p>
     * 可以为Cache对象添加一个移除监听器。这样，当有记录被删除时，可以感知到这个事件
     * <p>
     * 这个存在问题,当内存数据清理掉时候,RemovalListener不会触发
     * 因为
     * Guava并不保证在过期时间到了之后立刻删除该key，如果你此时去访问这这个key，它会检测是否过期，过期则移除.
     * 所以过期时间到了之后你去访问这个key会显示这个key已经移除，但是你如果不做任何操作，那么这个key还在内存中。
     * <p>
     * [key1:value1] is removed!
     * [key2:value2] is removed!
     * [key3:value3] is removed!
     * [key4:value4] is removed!
     * [key5:value5] is removed!
     */
    @Test
    public void test6() {
        RemovalListener<String, String> listener = new RemovalListener<String, String>() {
            public void onRemoval(RemovalNotification<String, String> notification) {
                System.out.println("[" + notification.getKey() + ":" + notification.getValue() + "] is removed!");
            }
        };
        Cache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(3)
                .removalListener(listener)
                .build();
        cache.put("key1", "value1");
        cache.put("key2", "value2");
        cache.put("key3", "value3");
        cache.put("key4", "value4");
        cache.put("key5", "value5");
        cache.put("key6", "value6");
        cache.put("key7", "value7");
        cache.put("key8", "value8");
    }


    private static final Cache<String, String> cache = CacheBuilder.newBuilder()
            .maximumSize(3)
            .build();

    /**
     * 自动加载
     * <p>
     * Cache的get方法有两个参数，第一个参数是从Cache中获取记录的key，第二个记录是一个Callable对象。
     * 当缓存中已经存在key对应的记录时，get方法直接返回key对应的记录。如果缓存中不包含key对应的记录，Guava会启动一个线程执行Callable对象中的call方法.
     * call方法的返回值会作为“key对应的值”被存储到缓存中，并且被get方法返回。
     * <p>
     * 有两个线程共享同一个Cache对象，两个线程同时调用get方法获取同一个key对应的值。由于key对应的值不存在，所以两个线程都在get方法处阻塞。
     * 此处在call方法中调用Thread.sleep(1000)，模拟程序从外存加载数据的时间消耗。
     * 虽然是两个线程同时调用get方法，但只有一个get方法中的Callable会被执行(只打印出load1或者load2)。
     * Guava可以保证当有多个线程同时访问Cache中的一个key时，如果key对应的记录不存在，Guava只会启动一个线程执行get方法中Callable参数对应的任务，加载数据存到缓存。
     * 当加载完数据后，任何线程中的get方法都会获取到key对应的值。
     * <p>
     * thread1
     * thread2
     * load2
     * thread1 auto load by Callable 2
     * thread2 auto load by Callable 2
     */
    @Test
    public void test7() throws InterruptedException {
        new Thread(() -> {
            System.out.println("thread1");
            try {
                String value = cache.get("key", () -> {
                    System.out.println("load1"); //加载数据线程执行标志
                    Thread.sleep(1000); //模拟加载时间
                    return "auto load by Callable 1";
                });
                System.out.println("thread1 " + value);
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }).start();

        new Thread(() -> {
            System.out.println("thread2");
            try {
                String value = cache.get("key", () -> {
                    System.out.println("load2"); //加载数据线程执行标志
                    Thread.sleep(1000); //模拟加载时间
                    return "auto load by Callable 2";
                });
                System.out.println("thread2 " + value);
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }).start();

        TimeUnit.SECONDS.sleep(5);
    }

    /**
     * 统计信息
     * <p>
     * 可以对Cache的命中率、加载数据时间等信息进行统计。
     * 在构建Cache对象时，通过CacheBuilder的recordStats方法，可以开启统计信息的开关。
     * 开关开启后，Cache会自动对缓存的各种操作进行统计，调用Cache的stats方法可以查看统计后的信息。
     */
    @Test
    public void test8() {
        Cache<String, String> cache = CacheBuilder.newBuilder()
                .maximumSize(3)
                .recordStats() //开启统计信息开关
                .build();
        cache.put("key1", "value1");
        cache.put("key2", "value2");
        cache.put("key3", "value3");
        cache.put("key4", "value4");
        cache.getIfPresent("key1");
        cache.getIfPresent("key2");
        cache.getIfPresent("key3");
        cache.getIfPresent("key4");
        cache.getIfPresent("key5");
        cache.getIfPresent("key6");
        System.out.println(cache.stats()); //获取统计信息
    }

}

1. LoadingCache

@Data
@AllArgsConstructor
class Customer {
  private Integer id;
  
  private String firstName;
}

/**
 * @Auther Chris Lee
 * @Date 1/3/2019 10:50
 * @Description LoadingCache是Cache的子接口，相比较于Cache，当从LoadingCache中读取一个指定key的记录时，如果该记录不存在，则LoadingCache可以自动执行加载数据到缓存的操作.
 * 在调用CacheBuilder的build方法时必须传递一个CacheLoader类型的参数，CacheLoader的load方法需要我们提供具体实现。
 * 当调用LoadingCache的get方法时，如果缓存不存在对应key的记录，则CacheLoader中的load方法会被自动调用从外存加载数据，“load方法的返回值”会作为“key对应的value”存储到LoadingCache中，并从get方法返回。
 */
public enum CustomerCacheProvider {
    INSTANCE;

    private final LoadingCache<Integer, Customer> customerCache;

    CustomerCacheProvider() {
        CacheLoader<Integer, Customer> cacheLoader = new CacheLoader<Integer, Customer>() {
            @Override
            public Customer load(Integer id) {
                return CustomerRepo.findById(id);
            }
        };
        customerCache = CacheBuilder.newBuilder().maximumSize(100).expireAfterWrite(2, TimeUnit.SECONDS).build(cacheLoader);
    }

    public LoadingCache<Integer, Customer> getCustomerCache() {
        return customerCache;
    }
}

/**
 * @Auther Chris Lee
 * @Date 1/3/2019 10:45
 * @Description
 */
class CustomerRepo {
    private static final Map<Integer, Customer> customers = new HashMap<>();

    static {
        // add data
        Customer customer1 = new Customer(1, "Jhon");
        Customer customer2 = new Customer(2, "James");
        Customer customer3 = new Customer(3, "Mark");

        customers.put(1, customer1);
        customers.put(2, customer2);
        customers.put(3, customer3);
    }

    public static Customer findById(Integer id) {
        System.out.printf("find %s in Repo \n", id);
        if (customers.containsKey(id)) {
            return customers.get(id);
        }
        return null;
    }
}

/**
 * @Auther Chris Lee
 * @Date 1/3/2019 10:52
 * @Description https://blog.csdn.net/qq_38567039/article/details/126488902
 */
public class Main {

    /**
     * 与构建Cache类型的对象类似，LoadingCache类型的对象也是通过CacheBuilder进行构建。
     * 不同的是，在调用CacheBuilder的build方法时，必须传递一个CacheLoader类型的参数，CacheLoader的load方法需要我们提供具体实现。
     * 当调用LoadingCache的get方法时，如果缓存不存在对应key的记录，则CacheLoader中的load方法会被自动调用从外存加载数据，
     * “load方法的返回值”会作为“key对应的value”存储到LoadingCache中，并从get方法返回。
     */
    @Test
    public void test1() {
        LoadingCache<Integer, Customer> cutomerCache = CustomerCacheProvider.INSTANCE.getCustomerCache();
        /*
         * V get(K key) : This will either return an already cached value, or else use the cache's CacheLoader to atomically
         * load a new value into the cache
         */
        try {
            System.out.println("Cache size : " + cutomerCache.size());
            System.out.println("Get Customer 1 : " + cutomerCache.get(1).getFirstName());
            System.out.println("Cache size : " + cutomerCache.size());
            TimeUnit.SECONDS.sleep(3);
            System.out.println("Get Customer 1 : " + cutomerCache.get(1).getFirstName());
            System.out.println("Get Customer 3 : " + cutomerCache.get(3).getFirstName());
            System.out.println("Cache size : " + cutomerCache.size());
        } catch (ExecutionException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

1. Type 简述

Type体系中类型的包括：原始类型(Class)、参数化类型(ParameterizedType)、数组类型(GenericArrayType)、类型变量(TypeVariable)、基本类型(Class);

- 原始类型，不仅仅包含我们平常所指的类，还包括枚举、数组、注解等；
- 参数化类型，就是我们平常所用到的泛型List、Map；
- 数组类型，并不是我们工作中所使用的数组String[] 、byte[]，而是带有泛型的数组，即T[] ；
- 基本类型，也就是我们所说的java的基本类型，即int,float,double等

2. ParameterizedType

Type的直接子接口ParameterizedType： 是参数化类型，即泛型，类似List、Map<Integer, String>、List<? extends Number>带有类型参数的类型，也可以是自定义的.

public interface ParameterizedType extends Type {
    // 获取泛型的类型,比如 Map<Integer,String> 获取的是 Integer和String
    Type[] getActualTypeArguments();

    // 获取<> 前面的类型,比如 Map<Integer,String> 获取的是Map
    Type getRawType();

     // For example, if this type is {@code O<T>.I<S>}, return a representation of {@code O<T>}.
    Type getOwnerType();
}

@Data
public class Person {
    List<Integer> integerList;
    Map<String, Integer> belongs;
}

/**
 * integerList 属性的原生类型为 interface java.util.List, 参数类型有:class java.lang.Integer
 * belongs 属性的原生类型为 interface java.util.Map, 参数类型有:class java.lang.String class java.lang.Integer
 */
@Test
public void test1() {
    Class<Person> clz = Person.class;
    Field[] declaredFields = clz.getDeclaredFields();
    Arrays.stream(declaredFields).forEach(field -> {
        if (field.getGenericType() instanceof ParameterizedType) {
            ParameterizedType parameterizedType = (ParameterizedType) field.getGenericType();
            System.out.printf("%s 属性的原生类型为 %s, 参数类型有:", field.getName(), parameterizedType.getRawType());
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
            for (Type actualTypeArgument : actualTypeArguments) {
                System.out.println(actualTypeArgument);
            }
        }
    });
}

3. TypeVariable

TypeVariable是各种类型变量的公共父接口，就是泛型里面的类似T、E。
在这需要强调的是，TypeVariable代表着泛型中的变量，而ParameterizedType则代表整个泛型

public interface GenericDeclaration extends AnnotatedElement {
    /**
     * 返回的泛型变量数组代表了泛型声明的内容，TypeVariable类型就是定义泛型变量的。
     */
    public TypeVariable<?>[] getTypeParameters();
}

GenericDeclaration 有三个直接子类 Class, Construtor, Method,也就是说只能在这几种对象上进行范型变量的声明（定义）。
GenericDeclaration的接口方法getTypeParameters用来逐个获取该GenericDeclaration的范型变量声明.

public interface TypeVariable<D extends GenericDeclaration> extends Type, AnnotatedElement {
    /**
     * 获得该类型变量的上限（上边界），若无显式定义（extends），默认为Object，类型变量的上限可能不止一个，因为可以用&符号限定多个（这其中有且只能有一个为类或抽象类，且必须放在extends后的第一个，即若有多个上边界，则第一个&后必为接口）
     * 比如 xxxClass<K extends List & Serialize>,则返回 List和Serialize
    */
    Type[] getBounds();

    /**
     *  获取的是在哪个类上进行的泛型声明,在如上的例子中,返回的是xxxClass
     * @since 1.5
     */
    D getGenericDeclaration();

    /**
     *  同样是上面的例子,返回 K, 也就是泛型类型声明时写的名字
     */
    String getName();

    /**
     * 
     * @since 1.8
     */
     AnnotatedType[] getAnnotatedBounds();
}

public class TestType<K extends List & Serializable, V> {

}

/**
 * [java.util.List, java.io.Serializable]
 * K
 * class com.chris.reflect.type.bean.TestType
 * -----------------
 * [java.lang.Object]
 * V
 * class com.chris.reflect.type.bean.TestType
 * -----------------
 */
@Test
public void test2() {
    TypeVariable[] v = TestType.class.getTypeParameters();

    for (TypeVariable t : v) {
        System.out.println(Arrays.stream(t.getBounds()).map(Type::getTypeName).collect(Collectors.toList()));
        System.out.println(t.getName());
        System.out.println(t.getGenericDeclaration());
        System.out.println("-----------------");
    }
}

Typora快捷键

https://www.cnblogs.com/hongdada/p/9776547.html
偏好设置->打开高级设置->conf.user.json文件

 "keyBinding": {
    // "Always on Top": "Ctrl+Shift+P"
	"Always on Top": "Ctrl+Shift+P",  
    "Code Fences": "Ctrl+Shift+F",  
    "Ordered List":"Ctrl+Alt+o",  
    "Unordered List": "Ctrl+Alt+u"  
  },

新增字体

Microsoft YaHe
font-size: 14px

#write {
  max-
  margin: 0 auto;
  padding: 20px 30px 160px;
}

编辑器自适应屏幕宽度

https://blog.csdn.net/qusikao/article/details/126737400

偏好设置，外观，打开主题文件夹
选择使用中的主题
将max-width的值调整为94%，意思是在全屏状态下编辑器窗口宽度会自动占用94%的宽度。

#write {
  max-width: 94%;
  margin: 0 auto;
  padding: 20px 30px 160px;
}

对于高阶版用户可能还会调整源文件编辑器宽度，依然是调整对应主题的css文件，代码如下：

#typora-source .CodeMirror-lines{
   max-width: 94%;
}

Docker

1 概述

1.1 是什么

基于Go语言实现的云开源项目
Docker的主要目标是：Build,Ship and Run any app, anywhere

1.2 解决了什么问题

解决了运行环境和配置问题软件容器，方便做系统集成并有助于整体发布的容器虚拟化技术

1.3 能干什么

更轻量：

基于容器的虚拟化，仅包含业务运行所需要的runtime环境[root用户权限，进程空间，用户空间和网络空间]
CentOS、Ubuntu基础镜像仅170M，这宿主机可部署100~1000个容器

更高效：

一次构建，随处运行
更快速高效的交付和部署系统
降低运维成本，更便捷的升级和扩容

1.4 三要素

镜像
容器
仓库

1.4.1 镜像image

镜像就是模板，可以用来创建Docker容器，一个镜像可以创建很多个容器

1.4.2 容器container

容器是用镜像创建的运行实例

1.4.3 仓库Repository

集中存放镜像文件的场所
仓库分为公开仓库和私有仓库
最大的公开仓库是 DockerHub https://hub.docker.com/
国内的公开仓库有阿里和网易

1.4.3 底层原理

1.4.3.1 是如何工作的

Docker是一个CS结构的系统，Docker守护进程运行在主机上，然后通过Socket连接从客户端访问，守护进程从客户端接受命令并管理运行在主机上的容器

2 安装

2.1 去哪下

官网：

http://www.docker.com
http://www.docker-cn.com

2.2 前提

Docker运行在CentOS7上要求系统版本为64位，内核版本为3.10以上
Docker运行在CentOS6.5上要求系统版本为64位，内核版本为2.6.32-431或以上

[root@master ~]# uname -r
3.10.0-1127.el7.x86_64

2.3 CentOS7 安装Docker

https://docs.docker.com/install/linux/docker-ce/centos

卸载老版本

sudo yum remove docker \
                  docker-client \
                  docker-client-latest \
                  docker-common \
                  docker-latest \
                  docker-latest-logrotate \
                  docker-logrotate \
                  docker-engine

安装仓库

sudo yum install -y yum-utils
sudo yum-config-manager \
    --add-repo \
    https://download.docker.com/linux/centos/docker-ce.repo

查看可用docker版本

yum list docker-ce --showduplicates | sort -r

安装指定版本

yum install docker-ce-19.03.8 docker-ce-cli-19.03.8 containerd.io

启动docker

systemctl start docker

2.4 阿里云镜像加速

https://dev.aliyun.com/search.html

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json
{
  "registry-mirrors": ["https://96rbv7qx.mirror.aliyuncs.com"]
}

sudo systemctl daemon-reload
sudo systemctl restart docker

docker run hello-world

[root@master ~]# docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
b8dfde127a29: Pull complete 
Digest: sha256:f2266cbfc127c960fd30e76b7c792dc23b588c0db76233517e1891a4e357d519
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

3 常用命令

3.1 帮助命令

描述	命令
查看版本	docker version
docker信息汇总	docker info
帮助命令	docker --help

3.2 镜像命令

3.2.1 查询本地镜像

描述	命令
列出本地镜像	docker images
列出本地所有镜像包括是间映像层	docker image -a
只显示镜像ID	docker image -q
显示镜像的摘要信息	docker image --digests
显示完整的镜像信息	docker image --no-trunc

[root@master ~]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
hello-world         latest              d1165f221234        6 weeks ago         13.3kB

REPOSITORY:镜像仓库源
TAG:镜像的标签
IMAGE ID:镜像ID
CREATED:镜像创建时间
SIZE:镜像大小

如查不你指定一个镜像的标签，docker默认使用hello-world:latest镜像

3.2.2 查询远程镜像

STARS:点赞数
OFFICIAL：官方版本

描述	命令
从[https://hub.docker.com]上查询镜像信息	docker search image-name
列出收藏数不小于30的镜像	docker search -s 30 image-name
显示完整的镜像信息	docker search --no-trunc image-name
只列出automated的镜像	docker search --automated image-name

3.2.3 拉取远程镜像

描述	命令
摘取远程镜像到本地，不加版本默认拉取最新版本	docker pull elasticsearch

3.2.4 删除镜像

描述	命令
删除本地镜像，不加版本默认删除最新版本	docker rmi elasticsearch
删除多个本地镜像，不加版本默认删除最新版本	docker rmi elasticsearch nginx
强制删除本地镜像，不加版本默认删除最新版本	docker rmi -f elasticsearch
强制删除本地所有镜像，不加版本默认删除最新版本	docker rmi -f $(docker images -q)

3.2.5 生成镜像

描述	命令
提交容器副本使之成为一个新的镜像	docker commit

docker commit -m="信息描述" -a="作者" 容器ID 要创建的目标镜像:[标签名]

[root@master ~]# docker commit -m "tomcat without doc" -a "chris" 3b7146c6590e christomcat:1.0
[root@master ~]# docker run -it -p 8888:8080 christomcat:1.0

3.3 容器命令

3.3.1 新建并启动容器

描述	命令
新建并启动容器	docker run [OPTIONS] (image-name|id) [COMMAND] [ARG...]
--name="指定新的容器名称"	docker run --name 指定新的容器名称 (image-name|id)
以交互方式运行容器通常与-t并用	docker run -i (image-name|id)
为容器重新分配一个伪输入终端	docker run -t (image-name|id)
随机端口映射	docker run -P (image-name
指定端口映射，有四种形式	docker run -p (image-name|id)
1	docker run -p ip:hostPort:containPort (image-name|id)
2	docker run -p ip::containPort (image-name|id)
3	docker run -p hostPort:containPort (image-name|id)
4	docker run -p containPort (image-name|id)
以守护的方启动容器	docker run -d (image-name|id)

docker run -it --name="es0422" elasticsearch /bin/bash
docker run -d centos
docker run -it -p 8080:8080 tomcat /bin/bash

3.3.2 列出所有正在运行的容器

描述	命令
所有正在运行的容器	docker ps [OPTIONS]
列出正在运行的和历史上运行过的容器	docker ps -a
列出最近创建的容器	docker ps -l
列出最近3个创建的容器	docker ps -n 3
静默模式，只显示容器编号	docker ps -q
不截断输出	docker ps --no-trunc

3.3.3 退出正在运行的容器

描述	命令
停止容器并退出	exit
退出但不停止容器	ctrl+p+q

3.3.4 启动停止容器

描述	命令
启动容器	docker start (container-name|id)
重新启动容器	docker restart (container-name|id)
停止容器	docker stop (container-name|id)
强制停止容器	docker kill (container-name|id)

3.3.5 删除容器

描述	命令
删除已停止的容器	docker rm (container-name|id)
强制删除容器无论容器是否已停止	docker rm (container-name|id)
一次性删除多个容器	docker rm -f $(docker ps -aq)
一次性删除多个容器	docker ps -aq | xargs docker rm

3.3.6 查看容器日志

docker run -d centos /bin/sh -c "while true; do echo hello zzyy;sleep 2;done"

[root@master docker]# docker run -d centos /bin/sh -c "while true; do echo hello zzyy;sleep 2;done"
9b5688f06fc2c4a52721e6dbcbba94062915211bbfaceb9473b8d3bfced736ce
[root@master ~]# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
9b5688f06fc2        centos              "/bin/sh -c 'while t…"   5 seconds ago       Up 2 seconds                            wonderful_goldwasser

docker logs -f -t --tail 3 9b5688f06fc2
-f: 打印最新的日志
-t: 加入时间戳
--tail: 显示最后多少条

[root@master ~]# docker logs -f -t --tail  3 9b5688f06fc2
2021-04-22T13:39:23.793299808Z hello zzyy
2021-04-22T13:39:25.804149907Z hello zzyy
2021-04-22T13:39:27.815085938Z hello zzyy
2021-04-22T13:39:29.826784950Z hello zzyy

3.3.7 容器内命令

描述	命令
查看容器内的进程	docker -ps
查看容器内的细节	docker inspect id

3.3.8 进入运行中的容器并以命令交互

描述	命令
进入容器正在执行的终端	docker attach id
进入容器内	docker exec -it id /bin/bash
在容器外操作执行命令	docker exec -it id ls -l /tmp

1. 进入当前容器后开启一个新的终端，可以在里面操作。（常用）
   docker exec
2. 进入容器正在执行某个命令的终端，不能在里面操作；多个窗口同时attach到同一个容器时，所有窗口同步显示；当某个窗口因命令阻塞，其他窗口也无法操作
   docker attach

[root@master docker]# docker attach 013c88f998bd
[root@013c88f998bd /]# ls -l /tmp
total 8
-rwx------. 1 root root 701 Dec  4 17:37 ks-script-esd4my7v
-rwx------. 1 root root 671 Dec  4 17:37 ks-script-eusq_sc5


[root@master ~]# docker exec 013c88f998bd ls -l /tmp
total 8
-rwx------. 1 root root 701 Dec  4 17:37 ks-script-esd4my7v
-rwx------. 1 root root 671 Dec  4 17:37 ks-script-eusq_sc5

3.3.9 copy文件

容器停止后容器里面之前改动的数据就会消失
docker cp id:/容器内路径 宿主机路径
docker cp id:/tmp/yum.log /root

4 镜像

4.1 是什么

联合文件系统(UnionFS)， 是一种分层，轻量级并且高性能的文件系统，它支持对文件系统的修改作为一次提交来一层层的叠加，同时将不同的目录挂载到同一个虚拟文件下

4.2 加载原理

bootfs(boot file system)：主要包含bootloader和kernel，bootloader主要是引导加载kernel，linux启动时会先加载bootfs，在Docker镜像的最底层就是bootfs,这一层与linux是一样的，当bootfs加载完成之后整个内核就都在内存中，此时内存的使用权就由bootfs转交给内核，同时系统也会卸载掉bootfs。

rootfs(root file system)：在bootfs之上包含了典型的linux系统中的/dev,/proc,/bin,/etc 等标准目录和文件。rootfs就是各种不同的操作系统发行版，比如Ubuntu或CentOS

为什么我们安装的CentOS要好几个G,但是docker里面的CentOS却只有200M
对于不同的linux发行版本bootfs是一致的，rootfs会有差别，对于一个精简的OS,可以共用系统的bootfs并提供自己的rootfs

tomcat镜像里面的分层结构

4.3 特点

Docker镜像都是只读的
当容器启动时，当容器启动时当一个新的可写层被加载到镜像的顶部。这一层通常被称作“容器层”，“容器层”之下叫作“镜像层”

5 数据卷

5.1 是什么

docker容器产生的数据，如果不通过docker commit生成新的镜像，当容器删除之后，数据就会消失
容器数据卷就是用来保存docker容器中的数据
卷是目录或文件，存在于一个或多个容器中，由docker挂载到容器，但是不属于UnionFS,因此能绕过UnionFS提供一些用于持久存储或共享数据的特性
卷的设计目的就是数据持久化，完全独立于容器的生命周期，因此docker不会在容器删除时删除挂载的数据卷

5.2 特点

1. 数据卷可以在容器之间共享或重用数据
2. 数据卷中的更改可以直接生效
3. 数据卷中的更改不会包含在镜像的更新中
4. 数据卷的生命周期一直持续到没有容器使用它为止

5.3 容器内添加数据卷

5.3.1 直接命令添加

docker run -it -v /宿主机目录绝对路径:容器内目录[权限:ro] 镜像名或ID
docker run -it -v /mydataVolume":/dataVolumeContainer: centos
在目录不存在的情况会自动创建目录， 如果创建添加权限:ro， 表示容器里面的数据卷只读但不能修改

# docker inspect 250d8813d860
"HostConfig": {
            "Binds": [
                "/mydataVolume:/dataVolumeContainer:"
            ],
}

"Mounts": [
            {
                "Type": "bind",
                "Source": "/mydataVolume",
                "Destination": "/dataVolumeContainer",
                "Mode": "",
                "RW": true,
                "Propagation": "rprivate"
            }
        ],

[root@master ~]# docker run -it -v /mydataVolume:/dataVolumeContainer: centos
[root@250d8813d860 /]# ls
bin  dataVolumeContainer  dev  etc  home  lib  lib64  lost+found  media  mnt  opt  proc  root  run  sbin  srv  sys  tmp  usr  var

[root@master /]# ll
total 24
lrwxrwxrwx.   1 root root    7 Dec 24 11:26 bin -> usr/bin
dr-xr-xr-x.   5 root root 4096 Dec 24 11:48 boot
drwxr-xr-x.  20 root root 3300 Apr 23 15:29 dev
drwxr-xr-x. 141 root root 8192 Apr 23 15:29 etc
drwxr-xr-x.   3 root root   19 Dec 24 11:53 home
lrwxrwxrwx.   1 root root    7 Dec 24 11:26 lib -> usr/lib
lrwxrwxrwx.   1 root root    9 Dec 24 11:26 lib64 -> usr/lib64
drwxr-xr-x.   2 root root    6 Apr 11  2018 media
drwxr-xr-x.   2 root root    6 Apr 11  2018 mnt
drwxr-xr-x.   2 root root    6 Apr 25 10:15 mydataVolume
drwxr-xr-x.   4 root root   34 Apr 22 13:49 opt
dr-xr-xr-x. 256 root root    0 Apr 23 15:28 proc
dr-xr-x---.   6 root root 4096 Apr 23 15:29 root
drwxr-xr-x.  43 root root 1340 Apr 25 06:35 run
lrwxrwxrwx.   1 root root    8 Dec 24 11:26 sbin -> usr/sbin
drwxr-xr-x.   2 root root    6 Apr 11  2018 srv
dr-xr-xr-x.  13 root root    0 Apr 23 15:28 sys
drwxrwxrwt.  22 root root 4096 Apr 25 10:15 tmp
drwxr-xr-x.  13 root root  155 Dec 24 11:26 usr
drwxr-xr-x.  20 root root  282 Dec 24 11:50 var

备注
Docker挂载主机目录Docker访问出现 cann't open directory.:Permission denied
解决办法在挂载目录后增加 --privileged true 参数即可
[root@master ~]# docker run -it -v /mydataVolume:/dataVolumeContainer: --privileged true centos

5.3.2 DockerFile添加

1. 新建dockerfile

mkdir mydocker  
cd mydocker  
vi dockerfile
写入如下命令

From centos
VOLUME ["/dataVolumeContainer01","/dataVolumeContainer02"]
CMD echo "finished,------success"
CMD /bin/bash

2. 生成镜像

docker build -f /mydocker/dockerfile -t chris/centos .
在当前目录下根据指定的dockerfile生成命名空间为chris镜像名称为centos的镜像

[root@master mydocker]# docker build -f /mydocker/dockerfile -t chris/centos .
Sending build context to Docker daemon  2.048kB
Step 1/4 : From centos
 ---> 300e315adb2f
Step 2/4 : VOLUME ["/dataVolumeContainer01","/dataVolumeContainer02"]
 ---> Running in 3a2ba255152a
Removing intermediate container 3a2ba255152a
 ---> 9522ef03e277
Step 3/4 : CMD echo "finished,------success"
 ---> Running in b6c0a82df0ad
Removing intermediate container b6c0a82df0ad
 ---> 7dff01de54a6
Step 4/4 : CMD /bin/bash
 ---> Running in af67b3613d42
Removing intermediate container af67b3613d42
 ---> f975da2854b7
Successfully built f975da2854b7
Successfully tagged chris/centos:latest

[root@master /]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
chris/centos        latest              f975da2854b7        3 minutes ago       209MB

3. 创建容器

[root@master ~]# docker run -it chris/centos /bin/bash
[root@22f74a27ccb0 /]# ls -l
total 0
lrwxrwxrwx.   1 root root   7 Nov  3 15:22 bin -> usr/bin
drwxr-xr-x.   2 root root   6 Apr 25 03:20 dataVolumeContainer01
drwxr-xr-x.   2 root root   6 Apr 25 03:20 dataVolumeContainer02
drwxr-xr-x.   5 root root 360 Apr 25 03:20 dev
drwxr-xr-x.   1 root root  66 Apr 25 03:20 etc
drwxr-xr-x.   2 root root   6 Nov  3 15:22 home
lrwxrwxrwx.   1 root root   7 Nov  3 15:22 lib -> usr/lib
lrwxrwxrwx.   1 root root   9 Nov  3 15:22 lib64 -> usr/lib64
drwx------.   2 root root   6 Dec  4 17:37 lost+found
drwxr-xr-x.   2 root root   6 Nov  3 15:22 media
drwxr-xr-x.   2 root root   6 Nov  3 15:22 mnt
drwxr-xr-x.   2 root root   6 Nov  3 15:22 opt
dr-xr-xr-x. 258 root root   0 Apr 25 03:20 proc
dr-xr-x---.   2 root root 162 Dec  4 17:37 root
drwxr-xr-x.  11 root root 163 Dec  4 17:37 run
lrwxrwxrwx.   1 root root   8 Nov  3 15:22 sbin -> usr/sbin
drwxr-xr-x.   2 root root   6 Nov  3 15:22 srv
dr-xr-xr-x.  13 root root   0 Apr 23 07:28 sys
drwxrwxrwt.   7 root root 145 Dec  4 17:37 tmp
drwxr-xr-x.  12 root root 144 Dec  4 17:37 usr
drwxr-xr-x.  20 root root 262 Dec  4 17:37 var

在数据卷中创建文件

[root@22f74a27ccb0 /]# cd dataVolumeContainer01
[root@22f74a27ccb0 dataVolumeContainer01]# vi container.txt

查看数据卷在容器和宿主机之间的路径关联关系

[root@master ~]# docker ps
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                    NAMES
22f74a27ccb0        chris/centos        "/bin/bash"         16 minutes ago      Up 16 minutes                                stupefied_cannon
692aee0e4bfe        christomcat:1.0     "catalina.sh run"   42 hours ago        Up 42 hours         0.0.0.0:8888->8080/tcp   epic_roentgen
3b7146c6590e        tomcat              "catalina.sh run"   43 hours ago        Up 43 hours         0.0.0.0:8088->8080/tcp   tomcat2
[root@master ~]# docker inspect 22f74a27ccb0
"Mounts": [
            {
                "Type": "volume",
                "Name": "f893623ee2039a23c820361dda8b45a164dc9a6a3e4329d30533ea6a73ad36e9",
                "Source": "/var/lib/docker/volumes/f893623ee2039a23c820361dda8b45a164dc9a6a3e4329d30533ea6a73ad36e9/_data",
                "Destination": "/dataVolumeContainer01",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            },
            {
                "Type": "volume",
                "Name": "feb81fb00529025525f7b27c20edc417eced5ce517cdf73c754343e943af50ba",
                "Source": "/var/lib/docker/volumes/feb81fb00529025525f7b27c20edc417eced5ce517cdf73c754343e943af50ba/_data",
                "Destination": "/dataVolumeContainer02",
                "Driver": "local",
                "Mode": "",
                "RW": true,
                "Propagation": ""
            }
        ]
[root@master ~]# cd /var/lib/docker/volumes/f893623ee2039a23c820361dda8b45a164dc9a6a3e4329d30533ea6a73ad36e9/_data
[root@master _data]# ll
total 4
-rw-r--r--. 1 root root 29 Apr 25 11:36 container.txt
        

5.4 数据卷容器

命名的容器挂载数据卷，其它容器通过挂载这个父容器实现数据共享，挂载数据卷的容器称之为数据卷容器
容器之间配置信息的传递，数据卷的生命周期一直持续到没有容器使用它为止

[root@master _data]# docker run -it --name dc01 chris/centos
[root@ca18f7f9d24c /]# cd dataVolumeContainer02
[root@ca18f7f9d24c dataVolumeContainer02]# touch dc01_add.txt

[root@master ~]# docker run -it --volumes-from dc01 --name dc02 chris/centos
[root@defe4e49519f /]# ls
bin  dataVolumeContainer01  dataVolumeContainer02  dev	etc  home  lib	lib64  lost+found  media  mnt  opt  proc  root	run  sbin  srv	sys  tmp  usr  var
[root@defe4e49519f /]# cd dataVolumeContainer0
[root@defe4e49519f dataVolumeContainer02]# ls
dc01_add.txt  

6 DockerFile

6.1 是什么

DockerFile是用来构建Docker镜像的构建文件，是由一系列的命令和参数组成的脚本。

6.2 构建三步骤

1. 编写DockerFile
2. 构建Docker镜像
3. 运行

6.3 DockerFile的解析过程

6.3.1 DockerFile的内容基础知识

1. 每个保留字命令必须为大写字母并且后面至少跟一个参数
2. 指令按从上到下顺序执行
3. #表示注释
4. 每条指令都会创建一个新的镜像层，并对镜像进行提交

6.3.2 DockerFile执行流程

1. docker从基础镜像运行一个容器
2. 执行一条指定并对容器作出修改
3. 执行类似docker commit 的操作提交一个新的镜像层
4. docker基于则提交的镜像再运行一个新的容器
5. 执行DockerFile中的下一条指令，直到所有的指令都被执行完成。

DockerFile是软件的原材料
Docker镜像是软件的交付物
Docker容器可以看成是软件的运行态
DockerFile面向开发，Docker镜像成为软件的交付标准，Docker容器则涉及部署到运维，三者缺一不可

6.4 指令

命令	描述
FROM	基础镜像，当前镜像是基于哪个镜像的
MAINTAINER	作者及其邮箱
RUN	容器构建时需要运行的linux命令
EXPOSE	容器运行时对外暴露的端口号
WORKDIR	进入容器运行后的目录，如果没有指定就是根目录
ENV	在构建镜像的过程中设置环境变量
ADD	将宿主机的文件拷贝进镜像且ADD命令会自动处理URL和解压TAR压缩包
COPY	类似ADD，将文件或目录拷贝到镜像中，将从构建上下文目录中<源路径>的文件/目录复制到新的一层镜像内的<目标路径>位置 COPY SRC DEST
VOLUME	指定数据卷，用于数据共享和持久化
CMD	指定一个容器启动时需要运行的命令,DockerFile中可以有多个CMD指令，但是只有最后一个生效，CMD会被docker run之后的参数替换
ENTRYPOINT	和CMD一样，指定一个容器启动时需要运行的命令，但是ENTRYPOINT只会追加，不会覆盖之前的命令
ONBUILD	当构建一个被继承的DockerFile时运行命令，父镜像在被子继承后父镜像的ONBUILD被触发

6.5. 案例

6.5.1 Base镜像(scratch)

DockerHub中有99%的镜像都是通过在Base镜像中安装或配置需要软件构建出来的

6.5.2 自定义镜像(mycentos)

1. 编写dockerfile

cd /mydocker
vi dockerfile_mycentos

FROM centos
ENV MYPATH /usr/local
WORKDIR $MYPATH

RUN yum -y install vim
RUN yum -y install net-tools

EXPOSE 80

CMD echo $MYPATH
CMD echo "success -------"
CMD /bin/bash

2. 构建

[root@master mydocker]# docker build -f dockerfile_mycentos -t chris/mycentos .
Sending build context to Docker daemon  2.048kB
Step 1/9 : FROM centos
 ---> 300e315adb2f
Step 2/9 : ENV MYPATH /usr/local
 ---> Running in 2949185ee980
Removing intermediate container 2949185ee980
 ---> 0f46cb36876f
Step 3/9 : WORKDIR $MYPATH
 ---> Running in fe888cab4aa9
Removing intermediate container fe888cab4aa9
 ---> 64d820bebb93
Step 4/9 : RUN yum -y install vim
 ---> Running in 96061faccf00
......

 ---> be8b79c33752
Step 6/9 : EXPOSE 80
 ---> Running in b2d74036a236
Removing intermediate container b2d74036a236
 ---> b7b067e37daa
Step 7/9 : CMD echo $MYPATH
 ---> Running in 1532b91d6170
Removing intermediate container 1532b91d6170
 ---> d4370aa3b2ff
Step 8/9 : CMD echo "success -------ok"
 ---> Running in 0fe95c30e852
Removing intermediate container 0fe95c30e852
 ---> 6c3800d76c3c
Step 9/9 : CMD /bin/bash
 ---> Running in 3a47cc176453
Removing intermediate container 3a47cc176453
 ---> eee12504217a
Successfully built eee12504217a
Successfully tagged chris/mycentos:latest
[root@master mydocker]# docker images 
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
chris/mycentos      latest              eee12504217a        2 minutes ago       291MB
tomcat              latest              c0e850d7b9bb        8 days ago          667MB
hello-world         latest              d1165f221234        8 weeks ago         13.3kB
centos              latest              300e315adb2f        4 months ago        209MB

3. 运行

[root@master mydocker]# docker run -it --name centos02 chris/mycentos
[root@960bafdfce5e local]# pwd
/usr/local

4. 列出镜像的变更历史

docker history 镜像名|ID
从下往上查看镜像的生成历史

[root@master chris]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
chris/mycentos      latest              eee12504217a        15 minutes ago      291MB
tomcat              latest              c0e850d7b9bb        8 days ago          667MB
hello-world         latest              d1165f221234        8 weeks ago         13.3kB
centos              latest              300e315adb2f        4 months ago        209MB
[root@master chris]# docker history chris/mycentos
IMAGE               CREATED             CREATED BY                                      SIZE                COMMENT
eee12504217a        15 minutes ago      /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "/bin…   0B                  
6c3800d76c3c        15 minutes ago      /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B                  
d4370aa3b2ff        15 minutes ago      /bin/sh -c #(nop)  CMD ["/bin/sh" "-c" "echo…   0B                  
b7b067e37daa        15 minutes ago      /bin/sh -c #(nop)  EXPOSE 80                    0B                  
be8b79c33752        15 minutes ago      /bin/sh -c yum -y install net-tools             23.4MB              
7b1c6d927962        16 minutes ago      /bin/sh -c yum -y install vim                   58.1MB              
64d820bebb93        16 minutes ago      /bin/sh -c #(nop) WORKDIR /usr/local            0B                  
0f46cb36876f        16 minutes ago      /bin/sh -c #(nop)  ENV MYPATH=/usr/local        0B                  
300e315adb2f        4 months ago        /bin/sh -c #(nop)  CMD ["/bin/bash"]            0B                  
<missing>           4 months ago        /bin/sh -c #(nop)  LABEL org.label-schema.sc…   0B                  
<missing>           4 months ago        /bin/sh -c #(nop) ADD file:bd7a2aed6ede423b7…   209MB               
[root@master chris]# 

6.5.3 CMD和ENTRYPOINT的区别

CMD 指的是下列表里面的COMMAND

[root@master chris]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
960bafdfce5e        chris/mycentos      "/bin/sh -c /bin/bash"   15 minutes ago      Up 15 minutes       80/tcp              centos02
8034e792d331        centos              "/bin/bash"              26 minutes ago      Up 26 minutes                           centos01

[root@master chris]# docker run -it --name tomcat02 -p 8888:8080  tomcat
[root@master chris]# docker ps 
CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS              PORTS                    NAMES
6b0b3c209535        tomcat              "catalina.sh run"   5 seconds ago       Up 4 seconds        0.0.0.0:8888->8080/tcp   tomcat02

在后面加 ls -l命令后，新增的tomcat03容器并没有启动

[root@master chris]# docker run -it --name tomcat03 -p 8088:8080  tomcat ls -l
total 128
-rw-r--r--. 1 root root 18984 Mar 30 10:29 BUILDING.txt
-rw-r--r--. 1 root root  5587 Mar 30 10:29 CONTRIBUTING.md
-rw-r--r--. 1 root root 57092 Mar 30 10:29 LICENSE
-rw-r--r--. 1 root root  2333 Mar 30 10:29 NOTICE
-rw-r--r--. 1 root root  3257 Mar 30 10:29 README.md
-rw-r--r--. 1 root root  6898 Mar 30 10:29 RELEASE-NOTES
-rw-r--r--. 1 root root 16507 Mar 30 10:29 RUNNING.txt
drwxr-xr-x. 2 root root  4096 Apr 22 23:10 bin
drwxr-xr-x. 2 root root   238 Mar 30 10:29 conf
drwxr-xr-x. 2 root root  4096 Apr 22 23:09 lib
drwxrwxrwx. 2 root root     6 Mar 30 10:29 logs
drwxr-xr-x. 2 root root   134 Apr 22 23:10 native-jni-lib
drwxrwxrwx. 2 root root    30 Apr 22 23:09 temp
drwxr-xr-x. 2 root root     6 Apr 22 23:09 webapps
drwxr-xr-x. 7 root root    81 Mar 30 10:29 webapps.dist
drwxrwxrwx. 2 root root     6 Mar 30 10:29 work

[root@master chris]# docker ps -a
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                      PORTS                    NAMES
81cbfbd01279        tomcat              "ls -l"                  6 seconds ago       Exited (0) 5 seconds ago                             tomcat03

原因：tomcat dockerfile 最后一行的CMD命令被 docker run 后面的 ls -l 替换掉

EXPOSE 8080
CMD ["catalina.sh", "run"]

[root@master]# cd /mydocker
[root@master]# vi myip01
FROM centos
RUN yum -y install curl
CMD ["curl","-s","http://www.ip.cn"]

[root@master mydocker]# docker build -f myip01 -t myip01:1.0 .
[root@master mydocker]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
myip01              1.0                 0ea4cc5030b2        7 seconds ago       243MB

[root@master]# cd /mydocker
[root@master]# vi myip02
FROM centos
RUN yum -y install curl
ENTRYPOINT ["curl","-s","http://www.ip.cn"]

[root@master mydocker]# docker build -f myip02 -t myip02:1.0 .
Sending build context to Docker daemon  4.096kB
Step 1/3 : FROM centos
 ---> 300e315adb2f
Step 2/3 : RUN yum -y install curl
 ---> Using cache
 ---> 552703ee39c9
Step 3/3 : ENTRYPOINT ["curl","-s","http://www.ip.cn"]
 ---> Running in 0dbc34763358
Removing intermediate container 0dbc34763358
 ---> a8f738d4a45a
Successfully built a8f738d4a45a
Successfully tagged myip02:1.0

6.5.4 ONBUILD

[root@master]# cd /mydocker
[root@master mydocker]# vi myip02_father

FROM centos
RUN yum -y install curl
ENTRYPOINT ["curl","-s","cip.cc"]
ONBUILD RUN echo "myip02_father image onbuild-----ok"

[root@master mydocker]# docker build -f myip02_father -t myip02_father:1.0 .
Sending build context to Docker daemon   5.12kB
Step 1/3 : FROM centos
 ---> 300e315adb2f
Step 2/3 : RUN yum -y install curl
 ---> Using cache
 ---> 552703ee39c9
Step 3/3 : ENTRYPOINT ["curl","-s","http://www.ip.cn"]
 ---> Using cache
 ---> a8f738d4a45a
Successfully built a8f738d4a45a
Successfully tagged myip02_father:1.0
[root@master mydocker]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
myip02_father       1.0                 a8f738d4a45a        3 minutes ago       243MB

[root@master]# cd /mydocker
[root@master mydocker]# vi myip02_kid
FROM myip02_father:1.0
RUN yum -y install curl
ENTRYPOINT ["curl","-s","cip.cc"]

[root@master mydocker]# docker build -f myip02_kid -t myip02_kid:1.0 .
Sending build context to Docker daemon  6.144kB
Step 1/3 : FROM myip02_father:1.0
# Executing 1 build trigger
 ---> Running in 61b5fd1fece7
myip02_father image onbuild-----ok
Removing intermediate container 61b5fd1fece7
 ---> 4d14bc2d40e8
Step 2/3 : RUN yum -y install curl
 ---> Running in e328e5961d4f
Last metadata expiration check: 0:08:57 ago on Sun May  2 01:54:21 2021.
Package curl-7.61.1-14.el8_3.1.x86_64 is already installed.
Dependencies resolved.
Nothing to do.
Complete!
Removing intermediate container e328e5961d4f
 ---> e44a48f55d44
Step 3/3 : ENTRYPOINT ["curl","-s","cip.cc"]
 ---> Running in d5e81a13e501
Removing intermediate container d5e81a13e501
 ---> df8fa730dfe4
Successfully built df8fa730dfe4
Successfully tagged myip02_kid:1.0

6.5.5 自定义tomcat9

1. 创建目录

mkdir -p /mydocker/christomcat9

2. 创建文件

[root@master]# cd /mydocker/christomcat9
[root@master chrisTomcat9]# touch c.txt
[root@master chrisTomcat9]# cp /opt/jdk-8u191-linux-x64.tar.gz .
[root@master chrisTomcat9]# cp /opt/apache-tomcat-9.0.38.tar.gz .
[root@master chrisTomcat9]# touch Dockerfile

FROM         centos
MAINTAINER    chris<lilunlogic@163.com>
#把宿主机当前上下文的c.txt拷贝到容器/usr/local/路径下
COPY c.txt /usr/local/cincontainer.txt
#把java与tomcat添加到容器中
ADD jdk-8u191-linux-x64.tar.gz  /usr/local/
ADD apache-tomcat-9.0.38.tar.gz /usr/local/
#安装vim编辑器
RUN yum -y install vim
#设置工作访问时候的WORKDIR路径，登录落脚点
ENV MYPATH /usr/local
WORKDIR $MYPATH
#配置java与tomcat环境变量
ENV JAVA_HOME /usr/local/jdk1.8.0_191
ENV CLASSPATH $JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
ENV CATALINA_HOME /usr/local/apache-tomcat-9.0.38
ENV CATALINA_BASE /usr/local/apache-tomcat-9.0.38
ENV PATH $PATH:$JAVA_HOME/bin:$CATALINA_HOME/lib:$CATALINA_HOME/bin
#容器运行时监听的端口
EXPOSE  8080
#启动时运行tomcat
# ENTRYPOINT ["/usr/local/apache-tomcat-9.0.38/bin/startup.sh" ]
# CMD ["/usr/local/apache-tomcat-9.0.38/bin/catalina.sh","run"]
CMD /usr/local/apache-tomcat-9.0.38/bin/startup.sh && tail -F /usr/local/apache-tomcat-9.0.38/bin/logs/catalina.out

3. 构建

[root@master chrisTomcat9]# docker build -t christomcat9 .
[root@master opt]# docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
christomcat9        latest              a02261dc7206        8 minutes ago       680MB

4. 运行

[root@master]# docker run -d -p 9080:8080 --name christomcat9 -v /mydocker/tomcat9/test:/usr/local/apache-tomcat-9.0.38/webapps/test -v /mydocker/tomcat9/tomcat9logs/:/usr/local/apache-tomcat-9.0.38/logs --privileged=true christomcat9

[root@master]# docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS                    NAMES
b2d9623ad57d        christomcat9        "/bin/sh -c '/usr/lo…"   7 seconds ago       Up 6 seconds        0.0.0.0:9080->8080/tcp   christomcat9

[root@master]# docker exec -it christomcat9 java -version
java version "1.8.0_191"
Java(TM) SE Runtime Environment (build 1.8.0_191-b12)
Java HotSpot(TM) 64-Bit Server VM (build 25.191-b12, mixed mode)

7 将镜像上传到阿里云

1. 创建镜像仓库

https://cr.console.aliyun.com/cn-hangzhou/instance/repositories
命名空间：chris0716
仓库名称：mydocker

2. 上传镜像

$ sudo docker login --username=lilunlogic@163.com registry.cn-hangzhou.aliyuncs.com
$ pwd:Lilun215+

$ sudo docker tag [ImageId] registry.cn-hangzhou.aliyuncs.com/chris0716/mydocker:[阿里云上显示的镜像版本号]
$ sudo docker push registry.cn-hangzhou.aliyuncs.com/chris0716/mydocker:[阿里云上显示的镜像版本号]

[root@master chris]# docker images
REPOSITORY                                             TAG                 IMAGE ID            CREATED             SIZE
christomcat9                                           latest              de6f4c6c9bcb        17 hours ago        680MB
registry.cn-hangzhou.aliyuncs.com/chris0716/mydocker   1.0                 de6f4c6c9bcb        17 hours ago        680MB
[root@master chris]# docker rmi registry.cn-hangzhou.aliyuncs.com/chris0716/mydocker:1.0
Untagged: registry.cn-hangzhou.aliyuncs.com/chris0716/mydocker:1.0
Untagged: registry.cn-hangzhou.aliyuncs.com/chris0716/mydocker@sha256:9ed6c267619595e22642c02a585bc75600d685cd7d93b4ea5c46c6292b30efd3
[root@master chris]# docker pull registry.cn-hangzhou.aliyuncs.com/chris0716/mydocker:1.0
1.0: Pulling from chris0716/mydocker
Digest: sha256:9ed6c267619595e22642c02a585bc75600d685cd7d93b4ea5c46c6292b30efd3
Status: Downloaded newer image for registry.cn-hangzhou.aliyuncs.com/chris0716/mydocker:1.0
registry.cn-hangzhou.aliyuncs.com/chris0716/mydocker:1.0
[root@master chris]# docker images
REPOSITORY                                             TAG                 IMAGE ID            CREATED             SIZE
christomcat9                                           latest              de6f4c6c9bcb        17 hours ago        680MB
registry.cn-hangzhou.aliyuncs.com/chris0716/mydocker   1.0                 de6f4c6c9bcb        17 hours ago        680MB